From e17090fadda2222d971bddda7e1c4fe179f3b4a7 Mon Sep 17 00:00:00 2001 From: jriegel Date: Sun, 5 Jan 2014 19:35:07 +0100 Subject: [PATCH] add SCL python files --- src/Mod/Import/App/CMakeLists.txt | 30 + .../Import/App/SCL/AggregationDataTypes.py | 602 + src/Mod/Import/App/SCL/BaseType.py | 69 + src/Mod/Import/App/SCL/Builtin.py | 716 + .../Import/App/SCL/ConstructedDataTypes.py | 139 + src/Mod/Import/App/SCL/Model.py | 55 + src/Mod/Import/App/SCL/Part21.py | 209 + src/Mod/Import/App/SCL/Rules.py | 39 + src/Mod/Import/App/SCL/SCLBase.py | 44 + src/Mod/Import/App/SCL/SimpleDataTypes.py | 216 + src/Mod/Import/App/SCL/TypeChecker.py | 101 + src/Mod/Import/App/SCL/Utils.py | 70 + src/Mod/Import/App/SCL/__init__.py | 1 + src/Mod/Import/App/SCL/essa_par.py | 74 + src/Mod/Import/App/automotive_design.py | 44542 ++++++++++++++++ src/Mod/Import/App/ifc2x3.py | 37012 +++++++++++++ src/Mod/Import/App/ifc4.py | 43883 +++++++++++++++ src/Mod/Material/CMakeLists.txt | 6 +- 18 files changed, 127807 insertions(+), 1 deletion(-) create mode 100644 src/Mod/Import/App/SCL/AggregationDataTypes.py create mode 100644 src/Mod/Import/App/SCL/BaseType.py create mode 100644 src/Mod/Import/App/SCL/Builtin.py create mode 100644 src/Mod/Import/App/SCL/ConstructedDataTypes.py create mode 100644 src/Mod/Import/App/SCL/Model.py create mode 100644 src/Mod/Import/App/SCL/Part21.py create mode 100644 src/Mod/Import/App/SCL/Rules.py create mode 100644 src/Mod/Import/App/SCL/SCLBase.py create mode 100644 src/Mod/Import/App/SCL/SimpleDataTypes.py create mode 100644 src/Mod/Import/App/SCL/TypeChecker.py create mode 100644 src/Mod/Import/App/SCL/Utils.py create mode 100644 src/Mod/Import/App/SCL/__init__.py create mode 100644 src/Mod/Import/App/SCL/essa_par.py create mode 100644 src/Mod/Import/App/automotive_design.py create mode 100644 src/Mod/Import/App/ifc2x3.py create mode 100644 src/Mod/Import/App/ifc4.py diff --git a/src/Mod/Import/App/CMakeLists.txt b/src/Mod/Import/App/CMakeLists.txt index e89a76a2d..4aa081e91 100644 --- a/src/Mod/Import/App/CMakeLists.txt +++ b/src/Mod/Import/App/CMakeLists.txt @@ -31,9 +31,39 @@ SET(Import_SRCS PreCompiled.h ) +SET(SCL_Resources + SCL/__init__.py + SCL/AggregationDataTypes.py + SCL/BaseType.py + SCL/Builtin.py + SCL/ConstructedDataTypes.py + SCL/essa_par.py + SCL/Model.py + SCL/Part21.py + SCL/Rules.py + SCL/SCLBase.py + SCL/SimpleDataTypes.py + SCL/TypeChecker.py + SCL/Utils.py + automotive_design.py # AP214e3 + ifc2x3.py # IFC + ifc4.py # IFC 4 +) +SOURCE_GROUP("SCL" FILES ${SCL_Resources}) + add_library(Import SHARED ${Import_SRCS}) target_link_libraries(Import ${Import_LIBS}) +ADD_CUSTOM_TARGET(ImportPy ALL + SOURCES ${SCL_Resources} +) + +fc_target_copy_resource(ImportPy + ${CMAKE_SOURCE_DIR}/src/Mod/Import/App + ${CMAKE_BINARY_DIR}/Mod/Import + ${SCL_Resources}) + + if(MSVC) set_target_properties(Import PROPERTIES SUFFIX ".pyd") set_target_properties(Import PROPERTIES DEBUG_OUTPUT_NAME "Import_d") diff --git a/src/Mod/Import/App/SCL/AggregationDataTypes.py b/src/Mod/Import/App/SCL/AggregationDataTypes.py new file mode 100644 index 000000000..0c324f56a --- /dev/null +++ b/src/Mod/Import/App/SCL/AggregationDataTypes.py @@ -0,0 +1,602 @@ +# Copyright (c) 2011, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from SimpleDataTypes import * +from TypeChecker import check_type +import BaseType + +class BaseAggregate(object): + """ A class that define common properties to ARRAY, LIST, SET and BAG. + """ + def __init__( self , bound1 , bound2 , base_type ): + # check that bound1bound2: + raise AssertionError("bound1 shall be less than or equal to bound2") + self._bound1 = bound1 + self._bound2 = bound2 + self._base_type = base_type + + def __getitem__(self, index): + if indexself._bound2): + raise IndexError("ARRAY index out of bound (upper bound is %i, passed %i)"%(self._bound2,index)) + else: + return list.__getitem__(self,index) + + def __setitem__(self,index,value): + if indexself._bound2): + raise IndexError("ARRAY index out of bound (upper bound is %i, passed %i)"%(self._bound2,index)) + elif not isinstance(value,self._base_type): + raise TypeError("%s type expected, passed %s."%(self._base_type, type(value))) + else: + # first find the length of the list, and extend it if ever + # the index is + list.__setitem__(self,index,value) + +class ARRAY(BaseType.Type, BaseType.Aggregate): + """ + EXPRESS definition: + ================== + An array data type has as its domain indexed, fixed-size collections of like elements. The lower + and upper bounds, which are integer-valued expressions, define the range of index values, and + thus the size of each array collection. + An array data type definition may optionally specify + that an array value cannot contain duplicate elements. + It may also specify that an array value + need not contain an element at every index position. + + Given that m is the lower bound and n is the upper bound, there are exactly n-m+1 elements + in the array. These elements are indexed by subscripts from m to n, inclusive (see 12.6.1). + NOTE 1 { The bounds may be positive, negative or zero, but may not be indeterminate (?) (see + 14.2). + + Syntax: + 165 array_type = ARRAY bound_spec OF [ OPTIONAL ] [ UNIQUE ] base_type . + 176 bound_spec = '[' bound_1 ':' bound_2 ']' . + 174 bound_1 = numeric_expression . + 175 bound_2 = numeric_expression . + 171 base_type = aggregation_types | simple_types | named_types . + Given that m is the lower bound and n is the upper bound, there are exactly n-m+1 elements + in the array. These elements are indexed by subscripts from m to n, inclusive (see 12.6.1). + NOTE 1 { The bounds may be positive, negative or zero, but may not be indeterminate (?) (see + 14.2). + Rules and restrictions: + a) Both expressions in the bound speci cation, bound_1 and bound_2, shall evaluate to + integer values. Neither shall evaluate to the indeterminate (?) value. + b) bound_1 gives the lower bound of the array. This shall be the lowest index which is + valid for an array value of this data type. + c) bound_2 gives the upper bound of the array. This shall be the highest index which is + valid for an array value of this data type. + d) bound_1 shall be less than or equal to bound_2. + e) If the optional keyword is speci ed, an array value of this data type may have the + indeterminate (?) value at one or more index positions. + f) If the optional keyword is not speci ed, an array value of this data type shall not + contain an indeterminate (?) value at any index position. + g) If the unique keyword is speci ed, each element in an array value of this data type + shall be di erent from (i.e., not instance equal to) every other element in the same array + value. + NOTE 2 : Both optional and unique may be speci ed in the same array data type definition. + This does not preclude multiple indeterminate (?) values from occurring in a single array value. + This is because comparisons between indeterminate (?) values result in unknown so the uniqueness + constraint is not violated. + EXAMPLE 27 : This example shows how a multi-dimensioned array is declared. + sectors : ARRAY [ 1 : 10 ] OF -- first dimension + ARRAY [ 11 : 14 ] OF -- second dimension + UNIQUE something; + The first array has 10 elements of data type ARRAY[11:14] OF UNIQUE something. There is + a total of 40 elements of data type something in the attribute named sectors. Within each + ARRAY[11:14], no duplicates may occur; however, the same something instance may occur in two + different ARRAY[11:14] values within a single value for the attribute named sectors. + + Python definition: + ================== + @TODO + """ + def __init__( self , bound_1 , bound_2 , base_type , UNIQUE = False, OPTIONAL=False, scope = None): + BaseType.Type.__init__(self, base_type, scope) + if not type(bound_1)==int: + raise TypeError("ARRAY lower bound must be an integer") + if not type(bound_2)==int: + raise TypeError("ARRAY upper bound must be an integer") + if not (bound_1 <= bound_2): + raise AssertionError("ARRAY lower bound must be less than or equal to upper bound") + # set up class attributes + self._bound_1 = bound_1 + self._bound_2 = bound_2 + self._unique = UNIQUE + self._optional = OPTIONAL + # preallocate list elements + list_size = bound_2 - bound_1 + 1 + self._container = list_size*[None] + + def bound_1(self): + return self._bound_1 + + def bound_2(self): + return self._bound_2 + + def get_hiindex(self): + return INTEGER(self._bound_2) + + def get_loindex(self): + return INTEGER(self._bound_1) + + def get_hibound(self): + return INTEGER(self._bound_2) + + def get_lobound(self): + return INTEGER(self._bound_1) + + def get_size(self): + return INTEGER(self._bound_2 - self._bound_1 +1) + + def get_value_unique(self): + ''' Return True if all items are different in the container, UNKNOWN if some items are + indeterminate, or False otherwise''' + if None in self._container: + return Unknown + if self.get_size()-len(set(self._container))>0: #some items are repeated + return False + else: + return True + + def __getitem__(self, index): + if indexself._bound_2): + raise IndexError("ARRAY index out of bound (upper bound is %i, passed %i)"%(self._bound_2,index)) + else: + value = self._container[index-self._bound_1] + if not self._optional and value==None: + raise AssertionError("Not OPTIONAL prevent the value with index %i from being None (default). Please set the value first."%index) + return value + + def __setitem__(self, index, value): + if indexself._bound_2): + raise IndexError("ARRAY index out of bound (upper bound is %i, passed %i)"%(self._bound_2,index)) + else: + # first check the type of the value + check_type(value,self.get_type()) + # then check if the value is already in the array + if self._unique: + if value in self._container: + raise AssertionError("UNIQUE keyword prevents inserting this instance.") + self._container[index-self._bound_1] = value + +class LIST(BaseType.Type, BaseType.Aggregate): + """ + EXPRESS definition: + ================== + A list data type has as its domain sequences of like elements. The optional lower and upper + bounds, which are integer-valued expressions, define the minimum and maximum number of + elements that can be held in the collection defined by a list data type. + A list data type + definition may optionally specify that a list value cannot contain duplicate elements. + + Syntax: + 237 list_type = LIST [ bound_spec ] OF [ UNIQUE ] base_type . + 176 bound_spec = '[' bound_1 ':' bound_2 ']' . + 174 bound_1 = numeric_expression . + 175 bound_2 = numeric_expression . + 171 base_type = aggregation_types | simple_types | named_types . + Rules and restrictions: + a) The bound_1 expression shall evaluate to an integer value greater than or equal to + zero. It gives the lower bound, which is the minimum number of elements that can be in a + list value of this data type. bound_1 shall not produce the indeterminate (?) value. + b) The bound_2 expression shall evaluate to an integer value greater than or equal to + bound_1, or an indeterminate (?) value. It gives the upper bound, which is the maximum + number of elements that can be in a list value of this data type. + If this value is indeterminate (?) the number of elements in a list value of this data type is + not bounded from above. + c) If the bound_spec is omitted, the limits are [0:?]. + d) If the unique keyword is speci ed, each element in a list value of this data type shall + be di erent from (i.e., not instance equal to) every other element in the same list value. + EXAMPLE 28 { This example de nes a list of arrays. The list can contain zero to ten arrays. Each + array of ten integers shall be di erent from all other arrays in a particular list. + complex_list : LIST[0:10] OF UNIQUE ARRAY[1:10] OF INTEGER; + + Python definition: + ================== + @TODO + """ + def __init__( self , bound_1 , bound_2 , base_type , UNIQUE = False, scope = None): + BaseType.Type.__init__(self, base_type, scope) + if not type(bound_1)==int: + raise TypeError("LIST lower bound must be an integer") + # bound_2 can be set to None + self._unbounded = False + if bound_2 == None: + self._unbounded = True + elif not type(bound_2)==int: + raise TypeError("LIST upper bound must be an integer") + if not bound_1>=0: + raise AssertionError("LIST lower bound must be greater of equal to 0") + if (type(bound_2)==int and not (bound_1 <= bound_2)): + raise AssertionError("ARRAY lower bound must be less than or equal to upper bound") + # set up class attributes + self._bound_1 = bound_1 + self._bound_2 = bound_2 + self._unique = UNIQUE + # preallocate list elements if bounds are both integers + if not self._unbounded: + list_size = bound_2 - bound_1 + 1 + self._container = list_size*[None] + # for unbounded list, this will come after + else: + self._container = [None] + + def bound_1(self): + return self._bound_1 + + def bound_2(self): + return self._bound_2 + + def get_size(self): + number_of_indeterminates = self._container.count(None) + hiindex = len(self._container) - number_of_indeterminates + return INTEGER(hiindex) + + def get_hiindex(self): + ''' When V is a bag, list or set, the returned value is the actual number of elements in + the aggregate value.''' + number_of_indeterminates = self._container.count(None) + hiindex = len(self._container) - number_of_indeterminates + return INTEGER(hiindex) + + def get_loindex(self): + return INTEGER(1) + + def get_hibound(self): + hibound = self._bound_2 + if type(hibound)==int: + return INTEGER(hibound) + else: + return hibound + + def get_lobound(self): + lobound = self._bound_1 + if type(lobound)==int: + return INTEGER(lobound) + else: + return lobound + + def get_value_unique(self): + ''' Return True if all items are different in the container, UNKNOWN if some items are + indeterminate, or False otherwise''' + if None in self._container: + return Unknown + if self.get_size()-len(set(self._container))>0: #some items are repeated + return False + else: + return True + + def __getitem__(self, index): + # case bounded + if not self._unbounded: + if indexself._bound_2): + raise IndexError("ARRAY index out of bound (upper bound is %i, passed %i)"%(self._bound_2,index)) + else: + value = self._container[index-self._bound_1] + if value == None: + raise AssertionError("Value with index %i not defined. Please set the value first."%index) + return value + #case unbounded + else: + if index-self._bound_1>len(self._container): + raise AssertionError("Value with index %i not defined. Please set the value first."%index) + else: + value = self._container[index-self._bound_1] + if value == None: + raise AssertionError("Value with index %i not defined. Please set the value first."%index) + return value + + def __setitem__(self, index, value): + # case bounded + if not self._unbounded: + if indexself._bound_2): + raise IndexError("ARRAY index out of bound (upper bound is %i, passed %i)"%(self._bound_2,index)) + else: + # first check the type of the value + check_type(value,self.get_type()) + # then check if the value is already in the array + if self._unique: + if value in self._container: + raise AssertionError("UNIQUE keyword prevent inserting this instance.") + self._container[index-self._bound_1] = value + # case unbounded + else: + if index=0: + raise AssertionError("LIST lower bound must be greater of equal to 0") + if (type(bound_2)==int and not (bound_1 <= bound_2)): + raise AssertionError("ARRAY lower bound must be less than or equal to upper bound") + # set up class attributes + self._bound_1 = bound_1 + self._bound_2 = bound_2 + self._container = [] + + def bound_1(self): + return self._bound_1 + + def bound_2(self): + return self._bound_2 + + def add(self,value): + ''' + Adds a value to the bag + ''' + if self._unbounded: + check_type(value,self.get_type()) + self._container.append(value) + else: + # first ensure that the bag is not full + if len(self._container) == self._bound_2 - self._bound_1 + 1: + raise AssertionError('BAG is full. Impossible to add any more item') + else: + check_type(value,self.get_type()) + self._container.append(value) + + def get_size(self): + ''' When V is a bag, list or set, the returned value is the actual number of elements in + the aggregate value.''' + return INTEGER(len(self._container)) + + def get_hiindex(self): + ''' When V is a bag, list or set, the returned value is the actual number of elements in + the aggregate value.''' + return INTEGER(len(self._container)) + + def get_loindex(self): + return INTEGER(1) + + def get_hibound(self): + hibound = self._bound_2 + if type(hibound)==int: + return INTEGER(hibound) + else: + return hibound + + def get_lobound(self): + lobound = self._bound_1 + if type(lobound)==int: + return INTEGER(lobound) + else: + return lobound + def get_value_unique(self): + ''' Return True if all items are different in the container, UNKNOWN if some items are + indeterminate, or False otherwise''' + if None in self._container: + return Unknown + if self.get_size()-len(set(self._container))>0: #some items are repeated + return False + else: + return True + + +class SET(BaseType.Type, BaseType.Aggregate): + """ + EXPRESS definition: + ================== + A set data type has as its domain unordered collections of like elements. The set data type is + a specialization of the bag data type. The optional lower and upper bounds, which are integer- + valued expressions, de ne the minimum and maximum number of elements that can be held in + the collection de ned by a set data type. The collection de ned by set data type shall not + contain two or more elements which are instance equal. + Syntax: + 285 set_type = SET [ bound_spec ] OF base_type . + 176 bound_spec = '[' bound_1 ':' bound_2 ']' . + 174 bound_1 = numeric_expression . + 175 bound_2 = numeric_expression . + 171 base_type = aggregation_types | simple_types | named_types . + Rules and restrictions: + a) The bound_1 expression shall evaluate to an integer value greater than or equal to + zero. It gives the lower bound, which is the minimum number of elements that can be in a + set value of this data type. bound_1 shall not produce the indeterminate (?) value. + b) The bound_2 expression shall evaluate to an integer value greater than or equal to + bound_1, or an indeterminate (?) value. It gives the upper bound, which is the maximum + number of elements that can be in a set value of this data type. + If this value is indeterminate (?) the number of elements in a set value of this data type is + not be bounded from above. + c) If the bound_spec is omitted, the limits are [0:?]. + d) Each element in an occurrence of a set data type shall be di erent from (i.e., not + instance equal to) every other element in the same set value. + EXAMPLE 30 { This example de nes an attribute as a set of points (a named data type assumed + to have been declared elsewhere). + a_set_of_points : SET OF point; + The attribute named a_set_of_points can contain zero or more points. Each point instance (in + the set value) is required to be di erent from every other point in the set. + If the value is required to have no more than 15 points, the speci cation can provide an upper bound, + as in: + a_set_of_points : SET [0:15] OF point; + The value of the attribute named a_set_of_points now may contain no more than 15 points. + + Python definition: + ================== + The difference with the BAG class is that the base container for SET is a set object. + """ + def __init__( self , bound_1 , bound_2 , base_type , scope = None): + BaseType.Type.__init__(self, base_type, scope) + if not type(bound_1)==int: + raise TypeError("LIST lower bound must be an integer") + # bound_2 can be set to None + self._unbounded = False + if bound_2 == None: + self._unbounded = True + elif not type(bound_2)==int: + raise TypeError("LIST upper bound must be an integer") + if not bound_1>=0: + raise AssertionError("LIST lower bound must be greater of equal to 0") + if (type(bound_2)==int and not (bound_1 <= bound_2)): + raise AssertionError("ARRAY lower bound must be less than or equal to upper bound") + # set up class attributes + self._bound_1 = bound_1 + self._bound_2 = bound_2 + self._container = set() + + def bound_1(self): + return self._bound_1 + + def bound_2(self): + return self._bound_2 + + def add(self,value): + ''' + Adds a value to the bag + ''' + if self._unbounded: + check_type(value,self.get_type()) + self._container.add(value) + else: + # first ensure that the bag is not full + if len(self._container) == self._bound_2 - self._bound_1 + 1: + if not value in self._container: + raise AssertionError('SET is full. Impossible to add any more item') + else: + check_type(value,self.get_type()) + self._container.add(value) + + def get_size(self): + ''' When V is a bag, list or set, the returned value is the actual number of elements in + the aggregate value.''' + return INTEGER(len(self._container)) + + def get_hiindex(self): + ''' When V is a bag, list or set, the returned value is the actual number of elements in + the aggregate value.''' + return INTEGER(len(self._container)) + + def get_loindex(self): + return INTEGER(1) + + def get_hibound(self): + hibound = self._bound_2 + if type(hibound)==int: + return INTEGER(hibound) + else: + return hibound + + def get_lobound(self): + lobound = self._bound_1 + if type(lobound)==int: + return INTEGER(lobound) + else: + return lobound + + def get_value_unique(self): + ''' Return True if all items are different in the container, UNKNOWN if some items are + indeterminate, or False otherwise''' + if None in self._container: + return Unknown + else: + return True diff --git a/src/Mod/Import/App/SCL/BaseType.py b/src/Mod/Import/App/SCL/BaseType.py new file mode 100644 index 000000000..0698ba89b --- /dev/null +++ b/src/Mod/Import/App/SCL/BaseType.py @@ -0,0 +1,69 @@ +# Copyright (c) 2011, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +class Type(object): + ''' + A type can be defined from its name and scope + Looking into the scope dict returns the python type class. + This is the base class for aggregated data types or constructed data types + ''' + def __init__(self, typedef, scope): + self._scope = scope + self._typedef = typedef + + def get_scope(self): + return self._scope + + def get_type(self): + if type(self._typedef) == str: + if self._scope == None: + raise AssertionError('No scope defined for this type') + elif vars(self._scope).has_key(self._typedef): + return vars(self._scope)[self._typedef] + else: + raise TypeError("Type '%s' is not defined in given scope"%self._typedef) + else: + return self._typedef + +class Aggregate: + ''' + This is an abstract class. ARRAY, LIST, SET and BAG inherit from this class + ''' + pass + +if __name__ == "__main__": + import sys + scp = sys.modules[__name__] + class line: + pass + new_type = Type('lie',scp) + print new_type.get_type() + \ No newline at end of file diff --git a/src/Mod/Import/App/SCL/Builtin.py b/src/Mod/Import/App/SCL/Builtin.py new file mode 100644 index 000000000..69376e83e --- /dev/null +++ b/src/Mod/Import/App/SCL/Builtin.py @@ -0,0 +1,716 @@ +# Copyright (c) 2011-2012, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +__doc__ = "This module defines EXPRESS built in constants and functions" +import math + +from SimpleDataTypes import * +from BaseType import Aggregate +from AggregationDataTypes import * + +SCL_float_epsilon = 1e-7 +# Builtin constants + +# EXPRESS definition: +# =================== +#14.1 CONST_E is a REAL constant representing the mathematical value e, the base of the natural +#logarithm function (ln). +CONST_E = REAL(math.pi) + +# EXPRESS definition: +# =================== +#14.2 Indeterminate +#The indeterminate symbol (?) stands for an ambiguous value. It is compatible with all data +#types. +#NOTE - The most common use of indeterminate (?) is as the upper bound speci cation of a bag, +#list or set. This usage represents the notion that the size of the aggregate value de ned by the +#aggregation data type is unbounded. +# python note: indeterminate value is mapped to None in aggregate bounds + +# EXPRESS definition: +# =================== +#14.3 False +#false is a logical constant representing the logical notion of falsehood. It is compatible with +#the boolean and logical data types. +FALSE = False + +# EXPRESS definition: +# =================== +#14.4 Pi +#PI is a REAL constant representing the mathematical value , the ratio of a circle's circumference +#to its diameter. +PI = REAL(math.pi) + +# EXPRESS definition: +# =================== +#14.5 Self +#SELF refers to the current entity instance or type value. self may appear within an entity +#declaration, a type declaration or an entity constructor. +#NOTE - sSELF is not a constant, but behaves as one in every context in which it can appear. +# python note: SELF is not mapped to any constant, but is mapper to self + +# EXPRESS definition: +# =================== +#14.6 True +#true is a logical constant representing the logical notion of truth. It is compatible with the +#boolean and logical data types. +TRUE = True + +# EXPRESS definition: +# =================== +#14.7 Unknown +#unknown is a logical constant representing that there is insucient information available to +#be able to evaluate a logical condition. It is compatible with the logical data type, but not +#with the boolean data type. +# @TODO: define UNKNOWN in python + +# +# Builtin Functions +#15 Built-in functions +#All functions (and mathematical operations in general) are assumed to evaluate to exact results. +#The prototype for each of the built-in functions is given to show the type of the formal parameters +#and the result. +# + +# EXPRESS definition: +# =================== +#15.1 Abs - arithmetic function +#FUNCTION ABS ( V:NUMBER ) : NUMBER; +#The abs function returns the absolute value of a number. +#Parameters : V is a number. +#Result : The absolute value of V. The returned data type is identical to the data type of V. +#EXAMPLE 125 { ABS ( -10 ) --> 10 +# Python definition: +# ================== +# ABS is mapped to python abs builtin function +def ABS(V): + if not isinstance(V,NUMBER): + raise TypeError("ABS function takes a NUMBER parameter") + return type(V)(abs(V)) + +# EXPRESS definition: +# =================== +#15.2 ACos - arithmetic function +#FUNCTION ACOS ( V:NUMBER ) : REAL; +#The acos function returns the angle given a cosine value. +#Parameters : V is a number which is the cosine of an angle. +#Result : The angle in radians (0  result  ) whose cosine is V. +#Conditions : -1.0= 1.266103... +# Python definition: +# ================== +# ACOS is mapped to python math.acos builtin function +def ACOS(V): + if not isinstance(V,NUMBER): + raise TypeError("ACOS function takes a NUMBER parameter") + return REAL(math.acos(V)) + +# it's the same for ASIN and ATAN +def ASIN(V): + if not isinstance(V,NUMBER): + raise TypeError("ASIN function takes a NUMBER parameter") + return REAL(math.asin(V)) + +# EXPRESS definition: +# =================== +# 15.3 ATan - arithmetic function +#FUNCTION ATAN ( V1:NUMBER; V2:NUMBER ) : REAL; +#The atan function returns the angle given a tangent value of V , where V is given by the +#expression V = V1/V2. +#Parameters : +#a) V1 is a number. +#b) V2 is a number. +#Result : The angle in radians (-pi/2<=result<=pi/2) whose tangent is V. If V2 is zero, the result +#is pi/2 or -pi/2 depending on the sign of V1. +#Conditions : Both V1 and V2 shall not be zero. +#EXAMPLE 128 { ATAN ( -5.5, 3.0 ) --> -1.071449... +def ATAN(V1,V2): + if not isinstance(V1,NUMBER) and not isinstance(V2,NUMBER): + raise TypeError("ATAN function takes 2 NUMBER parameters") + if V2 == 0: + if V1>0: + return REAL(math.pi/2) + elif V1<0: + return REAL(-math.pi/2) + else: + raise ValueError("ATAN parameters can be both equal to zero") + else: + return REAL(math.atan(float(V1)/float(V2))) + +# EXPRESS definition: +# =================== +#15.5 BLength - binary function +#FUNCTION BLENGTH ( V:BINARY ) : INTEGER; +#The blength function returns the number of bits in a binary. +#Parameters : V is a binary value. +#Result : The returned value is the actual number of bits in the binary value passed. +#EXAMPLE 129 +#LOCAL +#n : NUMBER; +#x : BINARY := %01010010 ; +#END_LOCAL; +#... +#n := BLENGTH ( x ); -- n is assigned the value 8 +def BLENGTH(V): + if not isinstance(V,BINARY): + raise TypeError("BLENGTH function takes one BINARY parameter") + return INTEGER(len(V)) + +# EXPRESS definition: +# =================== +#15.6 Cos - arithmetic function +#FUNCTION COS ( V:NUMBER ) : REAL; +#The cos function returns the cosine of an angle. +#Parameters : V is a number which is an angle in radians. +#Result : The cosine of V (-1.0<=result<=1.0). +#EXAMPLE 130 { COS ( 0.5 ) --> 8.77582...E-1 +# +#15.21 Sin - arithmetic function +#FUNCTION SIN ( V:NUMBER ) : REAL; +#The sin function returns the sine of an angle. +#Parameters : V is a number representing an angle expressed in radians. +#Result : The sine of V (-1.0  result  1.0). +#EXAMPLE 144 { SIN ( PI ) --> 0.0 +# +def COS(V): + if not isinstance(V,NUMBER): + raise TypeError("COS function takes a NUMBER parameter") + return REAL(math.cos(V)) +def SIN(V): + if not isinstance(V,NUMBER): + raise TypeError("SIN function takes a NUMBER parameter") + return REAL(math.sin(V)) + +# EXPRESS definition: +# =================== +#15.7 Exists - general function +#FUNCTION EXISTS ( V:GENERIC ) : BOOLEAN; +#The exists function returns true if a value exists for the input parameter, or false if no value +#exists for it. The exists function is useful for checking if values have been given to optional +#attributes, or if variables have been initialized. +#Parameters : V is an expression which results in any type. +#Result : true or false depending on whether V has an actual or indeterminate (?) value. +#EXAMPLE 131 { IF EXISTS ( a ) THEN ... +def EXISTS(V): + if V==None: + return False + else: + return True + +# EXPRESS definition: +# =================== +#15.8 Exp - arithmetic function +#FUNCTION EXP ( V:NUMBER ) : REAL; +#The exp function returns e (the base of the natural logarithm system) raised to the power V. +#Parameters : V is a number. +#Result : The value eV . +#EXAMPLE 132 { EXP ( 10 ) --> 2.202646...E+4 +def EXP(V): + if not isinstance(V,NUMBER): + raise TypeError("EXP function takes a NUMBER parameter") + return REAL(math.exp(V)) + +# EXPRESS definition: +# =================== +#15.9 Format - general function +#FUNCTION FORMAT(N:NUMBER; F:STRING):STRING; +#The format returns a formatted string representation of a number. +#Parameters : +#a) N is a number (integer or real). +#b) F is a string containing formatting commands. +#Result : A string representation of N formatted according to F. Rounding is applied to the +#string representation if necessary. +#The formatting string contains special characters to indicate the appearance of the result. The +#formatting string can be written in three ways: +#a) The formatting string can give a symbolic description of the output representation. +#b) The formatting string can give a picture description of the output representation. +#c) When the formatting string is empty, a standard output representation is produced. +# Table 20: +#Number Format Display Comment +#10 +7I ' +10' Zero suppression +#10 +07I '+000010' Zeros not suppressed +#10 10.3E ' 1.000E+01' +#123.456789 8.2F ' 123.46' +#123.456789 8.2E '1.23E+02' +#123.456789 08.2E '0.12E+02' Preceding zero forced +#9.876E123 8.2E '9.88E+123' Exponent part is 3 characters +#and width ignored +#32.777 6I ' 33' Rounded +# Python definition +# ================= +# python string formatting is obtained from the val function +# @TODO: implement a safe eval or provide another implementation +# that avoids unsafe eval python builtin function. +def FORMAT(N,F): + if not isinstance(N,NUMBER): + raise TypeError("FORMAT function takes a NUMBER parameter") + if not isinstance(F,STRING): + raise TypeError("FORMAT function takes a NUMBER parameter") + py_formatting = F.lower() + string_to_evaluate = "'%" + string_to_evaluate += "%s'"%py_formatting + string_to_evaluate += "%" + string_to_evaluate += "%s"%N + result = eval(string_to_evaluate).upper() + return STRING(result) + +# EXPRESS definition: +# =================== +#15.10 HiBound - arithmetic function +#FUNCTION HIBOUND ( V:AGGREGATE OF GENERIC ) : INTEGER; +#The hibound function returns the declared upper index of an array or the declared upper +#bound of a bag, list or set. +#Parameters : V is an aggregate value. +#Result : +#a) When V is an array the returned value is the declared upper index. +#b) When V is a bag, list or set the returned value is the declared upper bound; if there +#are no bounds declared or the upper bound is declared to be indeterminate (?) indeterminate +#(?) is returned. +#EXAMPLE 133 { Usage of hibound function on nested aggregate values. +#LOCAL +#a : ARRAY[-3:19] OF SET[2:4] OF LIST[0:?] OF INTEGER; +#h1, h2, h3 : INTEGER; +#END_LOCAL; +#... +#a[-3][1][1] := 2; -- places a value in the list +#... +#h1 := HIBOUND(a); -- =19 (upper bound of array) +#h2 := HIBOUND(a[-3]); -- = 4 (upper bound of set) +#h3 := HIBOUND(a[-3][1]); -- = ? (upper bound of list (unbounded)) +def HIBOUND(V): + if not isinstance(V,Aggregate): + raise TypeError("HIBOUND takes an aggregate of generic") + return V.get_hibound() + +# EXPRESS definition: +# =================== +#15.11 HiIndex - arithmetic function +#FUNCTION HIINDEX ( V:AGGREGATE OF GENERIC ) : INTEGER; +#The hiindex function returns the upper index of an array or the number of elements in a bag, +#list or set +#Parameters : V is an aggregate value. +#Result : +#a) When V is an array, the returned value is the declared upper index. +#b) When V is a bag, list or set, the returned value is the actual number of elements in +#the aggregate value. +#EXAMPLE 134 { Usage of hiindex function on nested aggregate values. +#LOCAL +#a : ARRAY[-3:19] OF SET[2:4] OF LIST[0:?] OF INTEGER; +#h1, h2, h3 : INTEGER; +#END_LOCAL; +#a[-3][1][1] := 2; -- places a value in the list +#h1 := HIINDEX(a); -- = 19 (upper bound of array) +#h2 := HIINDEX(a[-3]); -- = 1 (size of set) -- this is invalid with respect +#-- to the bounds on the SET +#h3 := HIINDEX(a[-3][1]); -- = 1 (size of list) +def HIINDEX(V): + if not isinstance(V,Aggregate): + raise TypeError("HIINDEX takes an aggregate of generic") + return V.get_hiindex() + +# EXPRESS definition: +# =================== +#15.12 Length - string function +#FUNCTION LENGTH ( V:STRING ) : INTEGER; +#The length function returns the number of characters in a string. +#Parameters : V is a string value. +#Result : The returned value is the number of characters in the string and shall be greater than +#or equal to zero. +#EXAMPLE 135 - Usage of the length function. +#LOCAL +#n : NUMBER; +#x1 : STRING := 'abc'; +#x2 : STRING := "000025FF000101B5; +#END_LOCAL; +#... +#n := LENGTH ( x1 ); -- n is assigned the value 3 +#n := LENGTH ( x2 ); -- n is assigned the value 2 +def LENGTH(V): + if not isinstance(V,STRING): + raise TypeError("LENGTH take a STRING parameter") + return INTEGER(len(V)) + +# EXPRESS definition: +# =================== +#15.13 LoBound - arithmetic function +#FUNCTION LOBOUND ( V:AGGREGATE OF GENERIC ) : INTEGER; +#The lobound function returns the declared lower index of an array, or the declared lower +#bound of a bag, list or set. +#Parameters : V is an aggregate value. +#Result : +#a) When V is an array the returned value is the declared lower index. +#b) When V is a bag, list or set the returned value is the declared lower bound; if no +#lower bound is declared, zero (0) is returned. +#EXAMPLE 136 { Usage of lobound function on nested aggregate values. +#LOCAL +#a : ARRAY[-3:19] OF SET[2:4] OF LIST[0:?] OF INTEGER; +#h1, h2, h3 : INTEGER; +#END_LOCAL; +#... +#h1 := LOBOUND(a); -- =-3 (lower index of array) +#h2 := LOBOUND(a[-3]); -- = 2 (lower bound of set) +#h3 := LOBOUND(a[-3][1]); -- = 0 (lower bound of list) +def LOBOUND(V): + if not isinstance(V,Aggregate): + raise TypeError("HIBOUND takes an aggregate of generic") + return V.get_lobound() + +# EXPRESS definition: +# =================== +#15.14 Log - arithmetic function +#FUNCTION LOG ( V:NUMBER ) : REAL; +#The log function returns the natural logarithm of a number. +#Parameters : V is a number. +#Result : A real number which is the natural logarithm of V. +#Conditions : V > 0:0 +#EXAMPLE 137 { LOG ( 4.5 ) --> 1.504077...E0 +#15.15 Log2 - arithmetic function +#FUNCTION LOG2 ( V:NUMBER ) : REAL; +#The log2 function returns the base two logarithm of a number. +#Parameters : V is a number. +#Result : A real number which is the base two logarithm of V. +#Conditions : V > 0:0 +#EXAMPLE 138 { LOG2 ( 8 ) --> 3.00...E0 +#15.16 Log10 - arithmetic function +#FUNCTION LOG10 ( V:NUMBER ) : REAL; +#The log10 function returns the base ten logarithm of a number. +#Parameters : V is a number. +#Result : A real number which is the base ten logarithm of V. +#Conditions : V > 0:0 +#EXAMPLE 139 { LOG10 ( 10 ) --> 1.00...E0 +def LOG(V): + if not isinstance(V,NUMBER): + raise TypeError("LOG function takes a NUMBER parameter") + return REAL(math.log(V)) +def LOG2(V): + if not isinstance(V,NUMBER): + raise TypeError("LOG2 function takes a NUMBER parameter") + return REAL(math.log(V,2)) +def LOG10(V): + if not isinstance(V,NUMBER): + raise TypeError("LOG10 function takes a NUMBER parameter") + return REAL(math.log10(V)) + +# EXPRESS definition: +# =================== +#15.17 LoIndex - arithmetic function +#FUNCTION LOINDEX ( V:AGGREGATE OF GENERIC ) : INTEGER; +#The loindex function returns the lower index of an aggregate value. +#Parameters : V is an aggregate value. +#Result : +#a) When V is an array the returned value is the declared lower index. +#b) When V is a bag, list or set, the returned value is 1 (one). +#EXAMPLE 140 { Usage of loindex function on nested aggregate values. +#LOCAL +#a : ARRAY[-3:19] OF SET[2:4] OF LIST[0:?] OF INTEGER; +#h1, h2, h3 : INTEGER; +#END_LOCAL; +#... +#h1 := LOINDEX(a); -- =-3 (lower bound of array) +#h2 := LOINDEX(a[-3]); -- = 1 (for set) +#h3 := LOINDEX(a[-3][1]); -- = 1 (for list) +def LOINDEX(V): + if not isinstance(V,Aggregate): + raise TypeError("LOINDEX takes an aggregate of generic") + return V.get_loindex() + +# EXPRESS definition: +# =================== +#15.18 NVL - null value function +#FUNCTION NVL(V:GENERIC:GEN1; SUBSTITUTE:GENERIC:GEN1):GENERIC:GEN1; +#The nvl function returns either the input value or an alternate value in the case where the input +#has a indeterminate (?) value. +#Parameters : +#a) V is an expression which is of any type. +#b) SUBSTITUTE is an expression which shall not evaluate to indeterminate (?). +#Result : When V is not indeterminate (?) that value is returned. Otherwise, SUBSTITUTE is +#returned. +#EXAMPLE 141 { ENTITY unit_vector; +#x, y : REAL; +#z : OPTIONAL REAL; +#WHERE +#x**2 + y**2 + NVL(z, 0.0)**2 = 1.0; +#END_ENTITY; +#The nvl function is used to supply zero (0.0) as the value of Z when Z is indeterminate (?). +def NVL(V,SUBSTITUTE): + if V is not None: + return V + else: + return SUBSTITUTE + +# EXPRESS definition: +# =================== +#15.19 Odd - arithmetic function +#FUNCTION ODD ( V:INTEGER ) : LOGICAL; +#The odd function returns true or false depending on whether a number is odd or even. +#Parameters : V is an integer number. +#Result : When V MOD 2 = 1 true is returned; otherwise false is returned. +#Conditions : Zero is not odd. +#EXAMPLE 142 { ODD ( 121 ) --> TRUE +def ODD(V): + if not isinstance(V,INTEGER): + raise TypeError("ODD takes an INTEGER") + if V%2 == 0: + return False + else: + return True + +# EXPRESS definition: +# =================== +#15.20 RolesOf - general function +#FUNCTION ROLESOF ( V:GENERIC ) : SET OF STRING; +#The rolesof function returns a set of strings containing the fully quali ed names of the roles +#played by the speci ed entity instance. A fully quali ed name is de ned to be the name of the +#attribute quali ed by the name of the schema and entity in which this attribute is declared (i.e. +#'SCHEMA.ENTITY.ATTRIBUTE'). +#Parameters : V is any instance of an entity data type. +#Result : A set of string values (in upper case) containing the fully quali ed names of the +#attributes of the entity instances which use the instance V. +#When a named data type is use'd or reference'd, the schema and the name in that schema, +#if renamed, are also returned. Since use statements may be chained, all the chained schema +#names and the name in each schema are returned. +#EXAMPLE 143 { This example shows that a point might be used as the centre of a circle. The +#rolesof function determines what roles an entity instance actually plays. +#SCHEMA that_schema; +#ENTITY point; +#x, y, z : REAL; +#END_ENTITY; +#ENTITY line; +#start, +#end : point; +#END_ENTITY; +#END_SCHEMA; +#SCHEMA this_schema; +#USE FROM that_schema (point,line); +#CONSTANT +#origin : point := point(0.0, 0.0, 0.0); +#END_CONSTANT; +#ENTITY circle; +#centre : point; +#axis : vector; +#radius : REAL; +#END_ENTITY; +#... +#LOCAL +#p : point := point(1.0, 0.0, 0.0); +#c : circle := circle(p, vector(1,1,1), 1.0); +#l : line := line(p, origin); +#END_LOCAL; +#... +#IF 'THIS_SCHEMA.CIRCLE.CENTRE' IN ROLESOF(p) THEN -- true +#... +#IF 'THIS_SCHEMA.LINE.START' IN ROLESOF(p) THEN -- true +#... +#IF 'THAT_SCHEMA.LINE.START' IN ROLESOF(p) THEN -- true +#... +#IF 'THIS_SCHEMA.LINE.END' IN ROLESOF(p) THEN -- false +# +# Python note: +# @TODO: implement the ROLESOF function +def ROLESOF(V): + raise NotImplemented("Function ROLESOF not implemented") + +# EXPRESS definition: +# =================== +#15.22 SizeOf - aggregate function +#FUNCTION SIZEOF ( V:AGGREGATE OF GENERIC ) : INTEGER; +#The sizeof function returns the number of elements in an aggregate value. +#Parameters : V is an aggregate value. +#Result : +#a) When V is an array the returned value is its declared number of elements in the +#aggregation data type. +#b) When V is a bag, list or set, the returned value is the actual number of elements in +#the aggregate value. +#EXAMPLE 145 { LOCAL +#n : NUMBER; +#y : ARRAY[2:5] OF b; +#END_LOCAL; +#... +#n := SIZEOF (y); -- n is assigned the value 4 +def SIZEOF(V): + if not isinstance(V,Aggregate): + raise TypeError("SIZEOF takes an aggregate of generic") + return V.get_size() + +# EXPRESS definition: +# =================== +#15.23 Sqrt - arithmetic function +#FUNCTION SQRT ( V:NUMBER ) : REAL; +#The sqrt function returns the non-negative square root of a number. +#Parameters : V is any non-negative number. +#Result : The non-negative square root of V. +#Conditions : V  0:0 +#EXAMPLE 146 - SQRT ( 121 ) --> 11.0 +def SQRT(V): + if not isinstance(V,NUMBER): + raise TypeError("SQRT function takes a NUMBER parameter") + if V<0.0: + raise ValueError("SQRT takes a non-negative parameter") + return REAL(math.sqrt(V)) + +# EXPRESS definition: +# =================== +#15.24 Tan - arithmetic function +#FUNCTION TAN ( V:NUMBER ) : REAL; +#The tan function returns the tangent of of an angle. +#Parameters : V is a number representing an angle expressed in radians. +#Result : The tangent of the angle. If the angle is npi/2, where n is an odd integer, indeterminate +#(?) is returned. +#EXAMPLE 147 - TAN ( 0.0 ) --> 0.0 +def TAN(V): + if not isinstance(V,NUMBER): + raise TypeError("TAN function takes a NUMBER parameter") + # check if angle is npi/2 where n is an odd integer + a = V/(PI/2) + if abs(a%2-1.) < SCL_float_epsilon : + return None + else: + return REAL(math.tan(V)) + +# EXPRESS definition: +# =================== +#15.25 TypeOf - general function +#FUNCTION TYPEOF ( V:GENERIC ) : SET OF STRING; +#The typeof function returns a set of strings that contains the names of all the data types +#of which the parameter is a member. Except for the simple data types (binary, boolean, +#integer, logical, number, real, and string) and the aggregation data types (array, bag, +#list, set) these names are quali ed by the name of the schema which contains the de nition of +#the type. +#NOTE 1 { The primary purpose of this function is to check whether a given value (variable, at- +#tribute value) can be used for a certain purpose, e.g. to ensure assignment compatibility between +#two values. It may also be used if di erent subtypes or specializations of a given type have to be +#treated di erently in some context. +#Parameters : V is a value of any type. +#Result : The contents of the returned set of string values are the names (in upper case) of all +#types the value V is a member of. Such names are quali ed by the name of the schema which +#contains the de nition of the type ('SCHEMA.TYPE') if it is neither a simple data type nor an +#aggregation data type. It may be derived by the following algorithm (which is given here for +#specification purposes rather than to prescribe any particular type of implementation) +def TYPEOF(V): + # Create the set to return + v_types = set() + # append the type of V to the set + try: #it's a class + to_add = V.__name__.upper() + except AttributeError: #it's an instance, first retrieve the type + to_add = type(V).__name__.upper() + if not to_add in ['FLOAT','INT','AGGREGATE']: + v_types.add(to_add) + # recursively adds the base class names + for base_type in type(V).__bases__: + #print base_type + if not base_type == object: + v_types = v_types.union(TYPEOF(base_type)) + # finally, converts the v_types set to SET + return v_types + +# EXPRESS definition: +# =================== +#15.26 UsedIn - general function +#FUNCTION USEDIN ( T:GENERIC; R:STRING) : BAG OF GENERIC; +#The usedin function returns each entity instance that uses a speci ed entity instance in a +#speci ed role. +def USEDIN(T,R): + raise NotImplemented("USEDIN function not yet implemented.") + +# EXPRESS definition: +# =================== +#15.27 Value - arithmetic function +#FUNCTION VALUE ( V:STRING ) : NUMBER; +#The value function returns the numeric representation of a string. +#Parameters : V is a string containing either a real or integer literal. +#Result : A number corresponding to the string representation. If it is not possible to interpret +#the string as either a real or integer literal, indeterminate (?) is returned. +#EXAMPLE 151 { VALUE ( '1.234' ) --> 1.234 (REAL) +#VALUE ( '20' ) --> 20 (INTEGER) +#VALUE ( 'abc' ) --> ? null +def VALUE(V): + if not isinstance(V,STRING): + raise TypeError("VALULE function takes a NUMBER parameter") + # first try to instanciate an INTEGER from the string: + try: + return INTEGER(V) + except: + pass #not possible, try to cast to REAL + try: + return REAL(V) + except: + pass + # else return None + return None + +# EXPRESS definition: +# =================== +#15.28 Value in - membership function +#FUNCTION VALUE_IN ( C:AGGREGATE OF GENERIC:GEN; V:GENERIC:GEN ) : LOGICAL; +#The value in function returns a logical value depending on whether or not a particular value +#is a member of an aggregation. +#Parameters : +#a) C is an aggregation of any type. +#b) V is an expression which is assignment compatible with the base type of C. +#Result : +#a) If either V or C is indeterminate (?), unknown is returned. +#b) If any element of C has a value equal to the value of V, true is returned. +#c) If any element of C is indeterminate (?), unknown is returned. +#d) Otherwise false is returned. +#EXAMPLE 152 { The following test ensures that there is at least one point which is positioned at +#the origin. +#LOCAL +#points : SET OF point; +#END_LOCAL; +#... +#IF VALUE_IN(points, point(0.0, 0.0, 0.0)) THEN ... +def VALUE_IN(C,V): + if not isinstance(C,Aggregate): + raise TypeError("VALUE_IN method takes an aggregate as first parameter") + raise NotImplemented("VALUE_IN function not et implemented") + +# EXPRESS definition: +# =================== +#15.29 Value unique - uniqueness function +#FUNCTION VALUE UNIQUE ( V:AGGREGATE OF GENERIC) : LOGICAL; +#The value unique function returns a logical value depending on whether or not the elements +#of an aggregation are value unique. +#Parameters : V is an aggregation of any type. +#Result : +#a) If V is indeterminate (?), unknown is returned. +#b) If any any two elements of V are value equal, false is returned. +#c) If any element of V is indeterminate (?), unknown is returned. +#d) Otherwise true is returned. +#EXAMPLE 153 { The following test ensures tht each point is a set is at a di erent position, (by +#de nition they are distinct, i.e., instance unique). +#IF VALUE_UNIQUE(points) THEN ... +def VALUE_UNIQUE(V): + if not isinstance(V,Aggregate): + raise TypeError("VALUE_UNIQUE method takes an aggregate as first parameter") + return V.get_value_unique() + + \ No newline at end of file diff --git a/src/Mod/Import/App/SCL/ConstructedDataTypes.py b/src/Mod/Import/App/SCL/ConstructedDataTypes.py new file mode 100644 index 000000000..72ace3401 --- /dev/null +++ b/src/Mod/Import/App/SCL/ConstructedDataTypes.py @@ -0,0 +1,139 @@ +# Copyright (c) 2011, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import sys +import BaseType + +class EnumerationId(object): + """ + EXPRESS definition: + =================== + An enumeration data type has as its domain an ordered set of names. The names represent + values of the enumeration data type. These names are designated by enumeration_ids and are + referred to as enumeration items. + """ + pass + +class ENUMERATION(object): + """ + EXPRESS definition: + =================== + An ENUMERATION data type has as its domain an ordered set of names. The names represent + values of the enumeration data type. + + Python implementation: + ====================== + An enumeration is initialized from strings defining the types. + For instance, some EXPRESS definition: + TYPE ahead_or_behind = ENUMERATION OF + (ahead, + behind); + END_TYPE; -- ahead_or_behind + + is implemented in python with the line: + >>> ahead_of_behind = ENUMERATION('ahead','behind', the_current_scope) + >>> ahead_or_behind.ahead + >>> ahead_of_behind.behind + + And, if and only if ahead and/or behind are not in scope (e.g. they are not entity names, + and/or many enums define the same enumeration identifier): + >>> ahead + >>> behind + """ + def __init__(self,*kargs,**args): + # first defining the scope + if args.has_key('scope'): + self._scope = args['scope'] + else: + self._scope = None + # store passed enum identifiers + self._enum_id_names = list(kargs) + self._enum_ids = [] + # we create enums id from names, and create attributes + # for instance, from the identifier name 'ahead', + # we create an attribute ahead with which is a new + # instance of EnumerationId + for enum_id_name in self._enum_id_names: + setattr(self,enum_id_name,EnumerationId()) + # we store this new attributes to the enum_ids list, which + # will be accessed by the type checker with the get_enum_ids method + self._enum_ids.append(self.__getattribute__(enum_id_name)) + # + # Then we check if the enums names can be added to the current scope: + # if the name is already in the scope, then another enums id or select + # has the same name -> we do nothing, enums will be called + # with ahead_of_behind.ahead or ahead_or_behind.behind. + # otherwise, they can be called as only ahead or behind + # Note: since ENUMERATIONS are defined *before* entities, if an entity + # has the same name as an enum id, it will replace it in the current scope. + # + for enum_id_name in self._enum_id_names: + if not vars(self._scope).has_key(enum_id_name): + vars(self._scope)[enum_id_name] = self.__getattribute__(enum_id_name) + + def get_enum_ids(self): + return self._enum_ids + +class SELECT(object): + """ A select data type has as its domain the union of the domains of the named data types in + its select list. The select data type is a generalization of each of the named data types in its + select list. + """ + def __init__(self,*kargs,**args): + # first defining the scope + if args.has_key('scope'): + self._scope = args['scope'] + else: + self._scope = None + # create the types from the list of arguments + self._base_types = [] + for types in list(kargs): + new_type = BaseType.Type(types,self._scope) + self._base_types.append(new_type) + + def get_allowed_types(self): + _auth_types = [] + for types in self._base_types: + _auth_types.append(types.get_type()) + return _auth_types + + def get_allowed_basic_types(self): + ''' if a select contains some subselect, goes down through the different + sublayers untill there is no more ''' + b = [] + _auth_types = self.get_allowed_types() + for _auth_type in _auth_types: + if isinstance(_auth_type,SELECT) or isinstance(_auth_type,ENUMERATION): + h = _auth_type.get_allowed_types() + b.extend(h) + else: + b = _auth_types + return b diff --git a/src/Mod/Import/App/SCL/Model.py b/src/Mod/Import/App/SCL/Model.py new file mode 100644 index 000000000..9a3f0e87b --- /dev/null +++ b/src/Mod/Import/App/SCL/Model.py @@ -0,0 +1,55 @@ +# Copyright (c) 2011-2012, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +class Model(objet): + """ The container for entity instances + """ + def __init_(self): + print "Model initialized" + self._instances = [] + + def add_instance(self, entity_instance): + self._instances.append(entity_instance) + + def remove_instance(self, entity_instance): + self._instances.remove(entity_instance) + + def get_instances(self): + return self._instances + + def export_to_p21file(self, filename): + raise AssertionError("Not implemented") + + def export_to_p28file(self, filename): + raise AssertionError("Not implemented") + + + diff --git a/src/Mod/Import/App/SCL/Part21.py b/src/Mod/Import/App/SCL/Part21.py new file mode 100644 index 000000000..0f40d290b --- /dev/null +++ b/src/Mod/Import/App/SCL/Part21.py @@ -0,0 +1,209 @@ +# Copyright (c) 2011, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import re +import Utils +import time + + +INSTANCE_DEFINITION_RE = re.compile("#(\d+)[^\S\n]?=[^\S\n]?(.*?)\((.*)\)[^\S\n]?;[\\r]?$") + +def map_string_to_num(stri): + """ Take a string, check wether it is an integer, a float or not + """ + if ('.' in stri) or ('E' in stri): #it's definitely a float + return REAL(stri) + else: + return INTEGER(stri) + +class Model: + """ + A model contains a list of instances + """ + def __init__(self,name): + self._name = name + # a dict of instances + # each time an instance is added to the model, count is incremented + self._instances = {} + self._number_of_instances = 0 + + def add_instance(self, instance): + ''' + Adds an instance to the model + ''' + self._number_of_instances += 1 + self._instances[self._number_of_instances-1] = instance + + def print_instances(self): + ''' + Dump instances to stdout + ''' + for idx in range(self._number_of_instances): + "==========" + print "Instance #%i"%(idx+1) + print self._instances[idx] + +class Part21EntityInstance: + """ + A class to represent a Part21 instance as defined in one Part21 file + A Part21EntityInstance is defined by the following arguments: + entity_name: a string + entity_attributes: a list of strings to represent an attribute. + For instance, the following expression: + #4 = PRODUCT_DEFINITION_SHAPE('$','$',#5); + will result in : + entity : + entity_instance_attributes: ['$','$','#5'] + """ + def __init__(self,entity_name,attributes): + self._entity + self._attributes_definition = attributes + print self._entity_name + print self._attributes_definition + + +class Part21Parser: + """ + Loads all instances definition of a Part21 file into memory. + Two dicts are created: + self._instance_definition : stores attibutes, key is the instance integer id + self._number_of_ancestors : stores the number of ancestors of entity id. This enables + to define the order of instances creation. + """ + def __init__(self, filename): + self._filename = filename + # the schema + self._schema_name = "" + # the dict self._instances contain instance definition + self._instances_definition = {} + # this dict contains lists of 0 ancestors, 1 ancestor, etc. + # initializes this dict + self._number_of_ancestors = {} + for i in range(2000): + self._number_of_ancestors[i]=[] + self.parse_file() + # reduce number_of_ancestors dict + for item in self._number_of_ancestors.keys(): + if len(self._number_of_ancestors[item])==0: + del self._number_of_ancestors[item] + + def get_schema_name(self): + return self._schema_name + print schema_name + + def get_number_of_instances(self): + return len(self._instances_definition.keys()) + + def parse_file(self): + init_time = time.time() + print "Parsing file %s..."%self._filename, + fp = open(self._filename) + while True: + line = fp.readline() + if not line: + break + # there may be a multline definition. In this case, we read lines untill we found + # a ; + #while (not line.endswith(";\r\n")): #its a multiline + # line = line.replace("\r\n","") + fp.readline() + # parse line + match_instance_definition = INSTANCE_DEFINITION_RE.search(line) # id,name,attrs + if match_instance_definition: + instance_id, entity_name, entity_attrs = match_instance_definition.groups() + instance_int_id = int(instance_id) + # find number of ancestors + number_of_ancestors = entity_attrs.count('#') + # fill number of ancestors dict + self._number_of_ancestors[number_of_ancestors].append(instance_int_id) + # parse attributes string + entity_attrs_list, str_len = Utils.process_nested_parent_str(entity_attrs) + # then finally append this instance to the disct instance + self._instances_definition[instance_int_id] = (entity_name,entity_attrs_list) + else: #does not match with entity instance definition, parse the header + if line.startswith('FILE_SCHEMA'): + #identify the schema name + self._schema_name = line.split("'")[1].split("'")[0].split(" ")[0].lower() + fp.close() + print 'done in %fs.'%(time.time()-init_time) + print 'schema: - %s entities %i'%(self._schema_name,len(self._instances_definition.keys())) + +class EntityInstancesFactory(object): + ''' + This class creates entity instances from the str definition + For instance, the definition: + 20: ('CARTESIAN_POINT', ["''", '(5.,125.,20.)']) + will result in: + p = ARRAY(1,3,REAL) + p.[1] = REAL(5) + p.[2] = REAL(125) + p.[3] = REAL(20) + new_instance = cartesian_point(STRING(''),p) + ''' + def __init__(self, schema_name, instance_definition): + # First try to import the schema module + pass + +class Part21Population(object): + def __init__(self, part21_loader): + """ Take a part21_loader a tries to create entities + """ + self._part21_loader = part21_loader + self._aggregate_scope = [] + self._aggr_scope = False + self.create_entity_instances() + + def create_entity_instances(self): + """ Starts entity instances creation + """ + for number_of_ancestor in self._part21_loader._number_of_ancestors.keys(): + for entity_definition_id in self._part21_loader._number_of_ancestors[number_of_ancestor]: + self.create_entity_instance(entity_definition_id) + + def create_entity_instance(self, instance_id): + instance_definition = self._part21_loader._instances_definition[instance_id] + print "Instance definition to process",instance_definition + # first find class name + class_name = instance_definition[0].lower() + print "Class name:%s"%class_name + object_ = globals()[class_name] + # then attributes + #print object_.__doc__ + instance_attributes = instance_definition[1] + print "instance_attributes:",instance_attributes + a = object_(*instance_attributes) + +if __name__ == "__main__": + import time + import sys + from config_control_design import * + p21loader = Part21Parser("gasket1.p21") + print "Creating instances" + p21population = Part21Population(p21loader) diff --git a/src/Mod/Import/App/SCL/Rules.py b/src/Mod/Import/App/SCL/Rules.py new file mode 100644 index 000000000..1267a99d6 --- /dev/null +++ b/src/Mod/Import/App/SCL/Rules.py @@ -0,0 +1,39 @@ +# Copyright (c) 2011-2012, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +__doc__ = "This module defines EXPRESS rules" + +class Rule(object): + ''' + This class describes a RULE + @TODO: to be implemented + ''' + pass diff --git a/src/Mod/Import/App/SCL/SCLBase.py b/src/Mod/Import/App/SCL/SCLBase.py new file mode 100644 index 000000000..617c816ad --- /dev/null +++ b/src/Mod/Import/App/SCL/SCLBase.py @@ -0,0 +1,44 @@ +# Copyright (c) 2011, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +class BaseEntityClass(object): + """ A class that allows advanced __repr__ features for entity instances + """ + def __repr__(self): + """ Displays attribute with their values + """ + doc_string = "# %s class description:\n%s\n# Instance attributes:\n"%(self.__class__,self.__doc__) + # write each argument with its value + properties = dir(self) + for elem in properties: + if not elem.startswith("_"): + doc_string += "\t%s:%s\n"%(elem,self.__getattribute__(elem)) + return doc_string diff --git a/src/Mod/Import/App/SCL/SimpleDataTypes.py b/src/Mod/Import/App/SCL/SimpleDataTypes.py new file mode 100644 index 000000000..124c2483c --- /dev/null +++ b/src/Mod/Import/App/SCL/SimpleDataTypes.py @@ -0,0 +1,216 @@ +# Copyright (c) 2011, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +""" +Docstrings are courtesy of ISO 10303-11:1994(E) +""" + +class NUMBER: + """ + EXPRESS definition: + =================== + The number data type has as its domain all numeric values in the language. The number data + type shall be used when a more speci c numeric representation is not important. + Syntax: + 248 number_type = NUMBER . + EXAMPLE 15 - Since we may not know the context of size we do not know how to correctly + represent it, e.g. the size of the crowd at a football game would be an integer, whereas the area + of the pitch would be a real. + size : NUMBER ; + + Python definition: + ================== + class NUMBER is an abstract class, aimed at being specialized. + """ + pass + +class REAL(float,NUMBER): + """ + EXPRESS definition: + =================== + The real data type has as its domain all rational, irrational and scientfic real numbers. It is + a specialization of the number data type. + Syntax: + 265 real_type = REAL [ '(' precision_spec ')' ] . + 255 precision_spec = numeric_expression . + Rational and irrational numbers have infnite resolution and are exact. Scientific numbers rep- + resent quantities which are known only to a specified precision. The precision_spec is stated + in terms of significant digits. + A real number literal is represented by a mantissa and optional exponent. The number of digits + making up the mantissa when all leading zeros have been removed is the number of significant + digits. The known precision of a value is the number of leading digits that are necessary to the + application. + Rules and restrictions: + a) The precision_spec gives the minimum number of digits of resolution that are re- + quired. This expression shall evaluate to a positive integer value. + b) When no resolution specification is given the precision of the real number is uncon- + strained. + + Note 9.2.6: + integer and real are both specializations of number; + + Python definition: + ================== + REAL both inherits from float and NUMBER + """ + pass + +class INTEGER(int,NUMBER): + """ + EXPRESS definition: + =================== + The integer data type has as its domain all integer numbers. It is a specialization of the real + data type. + Syntax: + 227 integer_type = INTEGER . + EXAMPLE 16 - This example uses an integer data type to represent an attribute named nodes. + The domain of this attribute is all integers, with no further constraint. + ENTITY foo; + nodes : INTEGER; + END_ENTITY; + + Note 9.2.6: integer and real are both specializations of number; + + Python definition: + ================== + INTEGER both inherits from int and NUMBER + + @TODO: note 9.2.6 tells that integer is a specialization of real + """ + pass + +class STRING(str): + """ + The string data type has as its domain sequences of characters. The characters which are + permitted to form part of a string value are de ned in ISO 10646. + Syntax: + 293 string_type = STRING [ width_spec ] . + 318 width_spec = '(' width ')' [ FIXED ] . + 317 width = numeric_expression . + A string data type may be de ned as either xed or varying width (number of characters). If + it is not specfically defined as fixed width (by using the fixed reserved word in the dfinition) + the string has varying width. + + The domain of a xed width string data type is the set of all character sequences of exactly + the width speci ed in the type de nition. + The domain of a varying width string data type is the set of all character sequences of width + less than or equal to the maximum width speci ed in the type de nition. + If no width is speci ed, the domain is the set of all character sequences, with no constraint on + the width of these sequences. + Substrings and individual characters may be addressed using subscripts as described in 12.5. + The case (upper or lower) of letters within a string is signi cant. + + Python mapping: INTEGER is mapped the 'str' type. An additional width_spec parameter can be passed + to handle the FIXED length constraint + """ + pass + +class LOGICAL: + """ + The logical data type has as its domain the three literals true, false and unknown. + Syntax: + 243 logical_type = LOGICAL . + The following ordering holds for the values of the logical data type: false < unknown < + true. The logical data type is compatible with the boolean data type, except that the value + unknown cannot be assigned to a boolean variable. + """ + pass +Unknown = LOGICAL() + +# +#The boolean data type has as its domain the two literals true and false. The boolean data +#type is a specialization of the logical data type. +# +#Python mapping: BOOLEAN is mapped to 'bool' type +# +# The bool data type can't however be subclassed in Python (see +# See http://mail.python.org/pipermail/python-dev/2002-March/020822.html) +# so it is just set to bool +BOOLEAN = bool + +class BINARY(str): + """ + The binary data type has as its domain sequences of bits, each bit being represented by 0 or 1. + Syntax: + 172 binary_type = BINARY [ width_spec ] . + 318 width_spec = '(' width ')' [ FIXED ] . + 317 width = numeric_expression . + A binary data type may be defined as either fixed or varying width (number of bits). If it is + not specifically defined as fixed width (by using the fixed reserved word in the definition) the + binary data type has varying width. + The domain of a fixed width binary data type is the set of all bit sequences of exactly the width + speci ed in the type definition. + The domain of a varying width binary data type is the set of all bit sequences of width less + than or equal to the maximum width speci ed in the type de nition. If no width is specified, + the domain is the set of all bit sequences, with no constraint on the width of these sequences. + Subbinaries and individual bits may be addressed using subscripts as described in 12.3. + + Python mapping: BINARY is mapped to the 'str' type. A check is performed to validate it is a binary + string representing a number. + """ + def __new__(self, value, width=-1, fixed=False): + return str.__new__(self, value) + + def __init__(self, value, width=-1, fixed=False): + """ By default, lenght is set to None""" + self._specified_width = width + self._fixed = fixed + # Check implicit width + if (width!=-1) and not fixed: + raise ValueError("The 'width' parameter is passed but 'fixed' is still false. Please explicitely set 'fixed' to True to avoid implicit declaration") + # First check the string length if 'fixed' is set to True + if fixed: + if len(value) != width: + raise ValueError("The BINARY width %i is not consistent with the 'width' declaration(%i)"%(len(value),width)) + # Check that the value passed is actually a binary + try: + int(value,2) + except ValueError: + raise ValueError("%s is not a binary"%value) + + +if __name__=="__main__": + print "Creating REAL from float value" + a = REAL(1.5) + print a*2 + print "Creating REAL from string value" + a = REAL("1.2") + print a*3 + print "Creating INTEGER from int value" + b = INTEGER(2) + c = INTEGER(3) + print b+c + print "Creating INTEGER from string value" + e = INTEGER("5") + f = INTEGER("8") + print e*f + + \ No newline at end of file diff --git a/src/Mod/Import/App/SCL/TypeChecker.py b/src/Mod/Import/App/SCL/TypeChecker.py new file mode 100644 index 000000000..2c04faed5 --- /dev/null +++ b/src/Mod/Import/App/SCL/TypeChecker.py @@ -0,0 +1,101 @@ +# Copyright (c) 2011, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from ConstructedDataTypes import ENUMERATION, SELECT +import BaseType + +RAISE_EXCEPTION_IF_TYPE_DOES_NOT_MATCH = True +DEBUG = False + +def cast_python_object_to_aggregate(obj, aggregate): + """ This function casts a python object to an aggregate type. For instance: + [1.,2.,3.]-> ARRAY(1,3,REAL)""" + aggregate_lower_bound = aggregate.bound_1() + aggregate_upper_bound = aggregate.bound_2() + if type(obj)==list: + for idx in range(aggregate_lower_bound,aggregate_upper_bound+1): + aggregate[idx] = obj[idx-aggregate_lower_bound] + return aggregate + +def check_type(instance, expected_type): + """ This function checks wether an object is an instance of a given class + returns False or True + """ + type_match = False #by default, will be set to True if any match + if DEBUG: + print "===" + print "Instance passed: ",instance + print "Expected type: ", expected_type + # in the case of an enumeration, we have to check if the instance is in the list + if (isinstance(expected_type,ENUMERATION)): + allowed_ids = expected_type.get_enum_ids() + if instance in allowed_ids: + type_match = True + else: + raise TypeError('Enumeration ids must be %s ( passed %s)'%(allowed_ids,type(instance))) + elif (isinstance(expected_type,SELECT)): + # we check if the instance is of the type of any of the types that are in the SELECT + allowed_types = expected_type.get_allowed_basic_types() + for allowed_type in allowed_types: + if isinstance(instance,allowed_type): + type_match = True + if not type_match: + if RAISE_EXCEPTION_IF_TYPE_DOES_NOT_MATCH: + raise TypeError('Argument type must be %s (you passed %s)'%(allowed_types,type(instance))) + else: + print "WARNING: expected '%s' but passed a '%s', casting from python value to EXPRESS type"%(allowed_types, type(instance)) + return False + elif (isinstance(expected_type, BaseType.Aggregate)): + # first check that they are instance of the same class + if not (type(instance) == type(expected_type)): + raise TypeError('Expected %s but passed %s'%(type(expected_type),type(instance))) + # then check that the base type is the same + elif not (instance.get_type() == expected_type.get_type()): + #print instance.get_type() + #print expected_type.get_type() + raise TypeError('Expected %s:%s base type but passed %s:%s base type'%(type(expected_type),expected_type.get_type(),type(instance), instance.get_type())) + # check optional and unique attributes + #elif not (instance._unique == expected_type._unique): + # raise TypeError('Aggregate expects UNIQUE:%s property but passed UNIQUE:%s'%(expected_type._unique, instance._unique)) + #elif not (instance._optional == expected_type._optional): + # raise TypeError('Aggregate expects OPTIONAL:%s property but passed OPTIONAL:%s'%(expected_type._optional, instance._optional)) + # @TODO: check aggregate bounds + else: + type_match = True + else: # simple data types + type_match = isinstance(instance,expected_type) + if not type_match: + if RAISE_EXCEPTION_IF_TYPE_DOES_NOT_MATCH: + raise TypeError('Argument type must be %s (you passed %s)'%(expected_type,type(instance))) + else: + print "WARNING: expected '%s' but passed a '%s', casting from python value to EXPRESS type"%(expected_type, type(instance)) + return False + return True diff --git a/src/Mod/Import/App/SCL/Utils.py b/src/Mod/Import/App/SCL/Utils.py new file mode 100644 index 000000000..7cce22494 --- /dev/null +++ b/src/Mod/Import/App/SCL/Utils.py @@ -0,0 +1,70 @@ +# Copyright (c) 2011, Thomas Paviot (tpaviot@gmail.com) +# All rights reserved. + +# This file is part of the StepClassLibrary (SCL). +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. +# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +''' This module provide string utils''' + +def process_nested_parent_str(attr_str,idx=0): + ''' + The first letter should be a parenthesis + input string: "(1,4,(5,6),7)" + output: ['1','4',['5','6'],'7'] + ''' + params = [] + current_param = '' + k = 0 + while (k= 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE represented_definition +represented_definition = SELECT( + 'general_property', + 'property_definition', + 'property_definition_relationship', + 'shape_aspect', + 'shape_aspect_relationship', + scope = schema_scope) +# SELECT TYPE text_string_representation_item +text_string_representation_item = SELECT( + 'text_literal', + 'annotation_text', + 'annotation_text_character', + 'defined_character_glyph', + 'composite_text', + 'axis2_placement', + scope = schema_scope) +# SELECT TYPE event_occurrence_item +event_occurrence_item = SELECT( + 'action', + 'action_directive', + 'action_method', + 'action_property', + 'action_relationship', + 'action_request_solution', + 'alternate_product_relationship', + 'applied_action_assignment', + 'applied_classification_assignment', + 'applied_person_and_organization_assignment', + 'approval_status', + 'assembly_component_usage_substitute', + 'certification', + 'class_', + 'class_system', + 'configuration_design', + 'configuration_effectivity', + 'configuration_item', + 'configured_effectivity_assignment', + 'contract', + 'document_file', + 'draughting_model', + 'drawing_revision', + 'executed_action', + 'general_property', + 'material_designation', + 'mechanical_design_geometric_presentation_representation', + 'organization_relationship', + 'organizational_project', + 'person_and_organization', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_association', + 'product_concept_feature_category', + 'product_concept_feature_category_usage', + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_relationship', + 'product_definition_substitute', + 'property_definition', + 'requirement_for_action_resource', + 'resource_property', + 'security_classification', + 'security_classification_level', + 'shape_representation', + 'versioned_action_request', + scope = schema_scope) +# SELECT TYPE measure_value +measure_value = SELECT( + 'amount_of_substance_measure', + 'area_measure', + 'celsius_temperature_measure', + 'context_dependent_measure', + 'count_measure', + 'descriptive_measure', + 'electric_current_measure', + 'length_measure', + 'luminous_intensity_measure', + 'mass_measure', + 'numeric_measure', + 'non_negative_length_measure', + 'parameter_value', + 'plane_angle_measure', + 'positive_length_measure', + 'positive_plane_angle_measure', + 'positive_ratio_measure', + 'ratio_measure', + 'solid_angle_measure', + 'thermodynamic_temperature_measure', + 'time_measure', + 'volume_measure', + scope = schema_scope) +# SELECT TYPE person_organization_select +person_organization_select = SELECT( + 'person', + 'organization', + 'person_and_organization', + scope = schema_scope) +# SELECT TYPE presentation_size_assignment_select +presentation_size_assignment_select = SELECT( + 'presentation_view', + 'presentation_area', + 'area_in_set', + scope = schema_scope) +# SELECT TYPE date_and_time_item +date_and_time_item = SELECT( + 'action', + 'action_directive', + 'action_method', + 'action_property', + 'action_relationship', + 'action_request_solution', + 'alternate_product_relationship', + 'applied_action_assignment', + 'applied_classification_assignment', + 'applied_organization_assignment', + 'applied_person_and_organization_assignment', + 'approval_person_organization', + 'approval_status', + 'assembly_component_usage_substitute', + 'certification', + 'class_', + 'class_system', + 'configuration_design', + 'configuration_item', + 'configured_effectivity_assignment', + 'contract', + 'document_file', + 'draughting_model', + 'drawing_revision', + 'effectivity', + 'event_occurrence', + 'executed_action', + 'general_property', + 'material_designation', + 'mechanical_design_geometric_presentation_representation', + 'organization_relationship', + 'organizational_project', + 'person_and_organization', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_association', + 'product_concept_feature_category', + 'product_concept_feature_category_usage', + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_relationship', + 'product_definition_substitute', + 'property_definition', + 'requirement_for_action_resource', + 'resource_property', + 'security_classification', + 'security_classification_level', + 'shape_representation', + 'versioned_action_request', + scope = schema_scope) +# Defined datatype preferred_surface_curve_representation +class preferred_surface_curve_representation(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE property_or_shape_select +property_or_shape_select = SELECT( + 'property_definition', + 'shape_definition', + scope = schema_scope) +# SELECT TYPE rendering_properties_select +rendering_properties_select = SELECT( + 'surface_style_reflectance_ambient', + 'surface_style_transparent', + scope = schema_scope) +# Defined datatype u_direction_count +class u_direction_count(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype dimension_count +class dimension_count(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE spatial_rotation +spatial_rotation = SELECT( + 'ypr_rotation', + 'rotation_about_direction', + scope = schema_scope) +list_representation_item = LIST(1,None,'representation_item', scope = schema_scope) +# SELECT TYPE csg_select +csg_select = SELECT( + 'boolean_result', + 'csg_primitive', + scope = schema_scope) +# Defined datatype curve_tolerance_deviation +class curve_tolerance_deviation(positive_length_measure): + def __init__(self,*kargs): + pass + +# SELECT TYPE layered_item +layered_item = SELECT( + 'presentation_representation', + 'representation_item', + scope = schema_scope) +# SELECT TYPE pcurve_or_surface +pcurve_or_surface = SELECT( + 'pcurve', + 'surface', + scope = schema_scope) +# SELECT TYPE tolerance_deviation_select +tolerance_deviation_select = SELECT( + 'curve_tolerance_deviation', + 'surface_tolerance_deviation', + scope = schema_scope) +# Defined datatype positive_length_measure +class positive_length_measure(non_negative_length_measure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype dimension_extent_usage +class dimension_extent_usage(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE attribute_type +attribute_type = SELECT( + 'label', + 'text', + scope = schema_scope) +# Defined datatype box_width +class box_width(positive_ratio_measure): + def __init__(self,*kargs): + pass + +# SELECT TYPE id_attribute_select +id_attribute_select = SELECT( + 'action', + 'address', + 'product_category', + 'property_definition', + 'shape_aspect', + 'shape_aspect_relationship', + 'application_context', + 'group', + 'organizational_project', + 'representation', + scope = schema_scope) +# SELECT TYPE invisible_item +invisible_item = SELECT( + 'draughting_callout', + 'presentation_layer_assignment', + 'representation', + 'styled_item', + scope = schema_scope) +# SELECT TYPE kinematic_frame_background +kinematic_frame_background = SELECT( + 'point', + 'curve', + 'surface', + scope = schema_scope) +# Defined datatype numeric_measure +class numeric_measure(NUMBER): + def __init__(self,*kargs): + pass + +# Defined datatype box_slant_angle +class box_slant_angle(plane_angle_measure): + def __init__(self,*kargs): + pass + +# Defined datatype b_spline_curve_form +class b_spline_curve_form(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE effectivity_item +effectivity_item = SELECT( + 'action', + 'action_method', + 'action_method_relationship', + 'action_property', + 'action_relationship', + 'assembly_component_usage_substitute', + 'class_', + 'class_system', + 'configuration_design', + 'configuration_item', + 'configured_effectivity_assignment', + 'document_file', + 'draughting_model', + 'drawing_revision', + 'general_property', + 'material_designation', + 'mechanical_design_geometric_presentation_representation', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_association', + 'product_concept_feature_category', + 'product_concept_feature_category_usage', + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_relationship', + 'product_definition_substitute', + 'property_definition', + 'requirement_for_action_resource', + 'resource_property', + 'security_classification', + 'shape_aspect', + 'shape_representation', + scope = schema_scope) +# SELECT TYPE multi_language_attribute_item +multi_language_attribute_item = SELECT( + 'action', + 'action_directive', + 'action_method', + 'action_property', + 'action_relationship', + 'alternate_product_relationship', + 'application_context', + 'approval_relationship', + 'assembly_component_usage_substitute', + 'certification', + 'configuration_design', + 'configuration_item', + 'contract', + 'data_environment', + 'date_role', + 'date_time_role', + 'descriptive_representation_item', + 'document_relationship', + 'draughting_title', + 'effectivity', + 'effectivity_relationship', + 'event_occurrence', + 'external_source', + 'general_property', + 'general_property_relationship', + 'geometric_representation_item', + 'geometric_tolerance', + 'group', + 'group_relationship', + 'identification_role', + 'kinematic_pair', + 'mapped_item', + 'name_assignment', + 'organization_relationship', + 'organization_role', + 'organizational_project', + 'organizational_project_relationship', + 'pair_actuator', + 'person_and_organization_role', + 'presentation_layer_assignment', + 'process_product_association', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_association', + 'product_concept_relationship', + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_relationship', + 'product_definition_substitute', + 'product_related_product_category', + 'property_definition', + 'property_definition_relationship', + 'representation', + 'representation_relationship', + 'requirement_for_action_resource', + 'resource_property', + 'resource_requirement_type', + 'security_classification', + 'shape_aspect', + 'shape_aspect_relationship', + 'styled_item', + 'time_interval_role', + 'topological_representation_item', + 'uncertainty_measure_with_unit', + 'uncertainty_qualifier', + 'versioned_action_request', + 'versioned_action_request_relationship', + scope = schema_scope) +# SELECT TYPE draughting_titled_item +draughting_titled_item = SELECT( + 'drawing_revision', + 'drawing_sheet_revision', + scope = schema_scope) +# Defined datatype hour_in_day +class hour_in_day(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self < 24)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE surface_style_element_select +surface_style_element_select = SELECT( + 'surface_style_fill_area', + 'surface_style_boundary', + 'surface_style_silhouette', + 'surface_style_segmentation_curve', + 'surface_style_control_grid', + 'surface_style_parameter_line', + 'surface_style_rendering', + scope = schema_scope) +# Defined datatype v_direction_count +class v_direction_count(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype approximation_method +class approximation_method(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE security_classification_item +security_classification_item = SELECT( + 'action', + 'action_directive', + 'action_property', + 'applied_action_assignment', + 'assembly_component_usage_substitute', + 'class_system', + 'configuration_design', + 'configuration_effectivity', + 'configured_effectivity_assignment', + 'document_file', + 'draughting_model', + 'drawing_revision', + 'executed_action', + 'general_property', + 'material_designation', + 'mechanical_design_geometric_presentation_representation', + 'organizational_project', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_category', + 'product_definition', + 'product_definition_formation', + 'product_definition_relationship', + 'property_definition', + 'resource_property', + 'shape_representation', + 'versioned_action_request', + scope = schema_scope) +# SELECT TYPE dimensional_characteristic +dimensional_characteristic = SELECT( + 'dimensional_location', + 'dimensional_size', + scope = schema_scope) +# Defined datatype ratio_measure +class ratio_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE document_reference_item +document_reference_item = SELECT( + 'action_directive', + 'action_method', + 'action_relationship', + 'applied_action_assignment', + 'approval', + 'certification', + 'class_', + 'class_system', + 'configuration_design', + 'configuration_item', + 'contract', + 'descriptive_representation_item', + 'executed_action', + 'externally_defined_dimension_definition', + 'feature_definition', + 'general_property', + 'material_designation', + 'organization', + 'organizational_project', + 'person', + 'presentation_area', + 'process_plan', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_category', + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_process', + 'product_definition_relationship', + 'product_definition_substitute', + 'product_related_product_category', + 'property_definition', + 'representation', + 'resource_requirement_type', + 'retention', + 'security_classification', + 'shape_aspect', + 'shape_aspect_relationship', + 'versioned_action_request', + scope = schema_scope) +# Defined datatype si_unit_name +class si_unit_name(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype amount_of_substance_measure +class amount_of_substance_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE motion_parameter_measure +motion_parameter_measure = SELECT( + 'parameter_value', + 'measure_with_unit', + scope = schema_scope) +# Defined datatype day_in_month_number +class day_in_month_number(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((1 <= self) and (self <= 31)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE area_or_view +area_or_view = SELECT( + 'presentation_area', + 'presentation_view', + scope = schema_scope) +# Defined datatype electric_current_measure +class electric_current_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE founded_item_select +founded_item_select = SELECT( + 'founded_item', + 'representation_item', + scope = schema_scope) +# SELECT TYPE style_context_select +style_context_select = SELECT( + 'group', + 'presentation_layer_assignment', + 'presentation_set', + 'representation', + 'representation_item', + 'shape_representation_relationship', + scope = schema_scope) +# SELECT TYPE kinematic_analysis_definition +kinematic_analysis_definition = SELECT( + 'interpolated_configuration_sequence', + scope = schema_scope) +# SELECT TYPE source_item +source_item = SELECT( + 'identifier', + scope = schema_scope) +# Defined datatype trimming_preference +class trimming_preference(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE contract_item +contract_item = SELECT( + 'drawing_revision', + 'executed_action', + 'product_definition_formation', + scope = schema_scope) +# SELECT TYPE configured_effectivity_item +configured_effectivity_item = SELECT( + 'action_relationship', + 'process_plan', + 'product_definition', + 'product_process_plan', + scope = schema_scope) +# SELECT TYPE date_time_or_event_occurrence +date_time_or_event_occurrence = SELECT( + 'date_time_select', + 'event_occurrence', + scope = schema_scope) +# SELECT TYPE derived_property_select +derived_property_select = SELECT( + 'property_definition', + 'action_property', + 'resource_property', + scope = schema_scope) +# SELECT TYPE fill_area_style_tile_shape_select +fill_area_style_tile_shape_select = SELECT( + 'fill_area_style_tile_symbol_with_style', + scope = schema_scope) +# Defined datatype shading_surface_method +class shading_surface_method(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE vector_or_direction +vector_or_direction = SELECT( + 'vector', + 'direction', + scope = schema_scope) +# SELECT TYPE approval_item +approval_item = SELECT( + 'action', + 'action_directive', + 'action_property', + 'action_request_solution', + 'alternate_product_relationship', + 'applied_action_assignment', + 'applied_classification_assignment', + 'assembly_component_usage_substitute', + 'certification', + 'class_', + 'class_system', + 'configuration_design', + 'configuration_effectivity', + 'configured_effectivity_assignment', + 'contract', + 'document_file', + 'draughting_model', + 'drawing_revision', + 'executed_action', + 'general_property', + 'material_designation', + 'mechanical_design_geometric_presentation_representation', + 'organizational_project', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_association', + 'product_concept_feature_category', + 'product_concept_feature_category_usage', + 'product_definition', + 'product_definition_formation', + 'product_definition_relationship', + 'product_definition_substitute', + 'property_definition', + 'resource_property', + 'shape_representation', + 'versioned_action_request', + scope = schema_scope) +# Defined datatype volume_measure +class volume_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE geometric_set_select +geometric_set_select = SELECT( + 'point', + 'curve', + 'surface', + scope = schema_scope) +# Defined datatype positive_plane_angle_measure +class positive_plane_angle_measure(plane_angle_measure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype text_delineation +class text_delineation(label): + def __init__(self,*kargs): + pass + +# SELECT TYPE category_usage_item +category_usage_item = SELECT( + 'product_class', + scope = schema_scope) +# SELECT TYPE defined_symbol_select +defined_symbol_select = SELECT( + 'pre_defined_symbol', + 'externally_defined_symbol', + scope = schema_scope) +# Defined datatype b_spline_surface_form +class b_spline_surface_form(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype null_style +class null_style(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype marker_type +class marker_type(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE shell +shell = SELECT( + 'open_shell', + 'closed_shell', + scope = schema_scope) +# SELECT TYPE defined_glyph_select +defined_glyph_select = SELECT( + 'externally_defined_character_glyph', + scope = schema_scope) +# SELECT TYPE transformation +transformation = SELECT( + 'item_defined_transformation', + 'functionally_defined_transformation', + scope = schema_scope) +# Defined datatype unlimited_range +class unlimited_range(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE boolean_operand +boolean_operand = SELECT( + 'solid_model', + 'half_space_solid', + 'csg_primitive', + 'boolean_result', + scope = schema_scope) +# Defined datatype text_path +class text_path(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE date_time_select +date_time_select = SELECT( + 'date', + 'date_and_time', + 'local_time', + scope = schema_scope) +# Defined datatype solid_angle_measure +class solid_angle_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE csg_primitive +csg_primitive = SELECT( + 'sphere', + 'block', + 'right_angular_wedge', + 'torus', + 'right_circular_cone', + 'right_circular_cylinder', + scope = schema_scope) +ypr_rotation = ARRAY(ypr_index(yaw),ypr_index(roll),'REAL', scope = schema_scope) +# SELECT TYPE marker_select +marker_select = SELECT( + 'marker_type', + 'pre_defined_marker', + scope = schema_scope) +# Defined datatype surface_side +class surface_side(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype luminous_intensity_measure +class luminous_intensity_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE organization_item +organization_item = SELECT( + 'action', + 'action_directive', + 'action_method', + 'action_property', + 'action_relationship', + 'action_request_solution', + 'alternate_product_relationship', + 'applied_action_assignment', + 'applied_classification_assignment', + 'applied_identification_assignment', + 'applied_organization_assignment', + 'applied_person_and_organization_assignment', + 'approval', + 'approval_status', + 'assembly_component_usage_substitute', + 'certification', + 'class_', + 'class_system', + 'configuration_design', + 'configuration_effectivity', + 'configuration_item', + 'configured_effectivity_assignment', + 'contract', + 'document_file', + 'document_type', + 'draughting_model', + 'drawing_revision', + 'effectivity', + 'event_occurrence', + 'executed_action', + 'general_property', + 'material_designation', + 'mechanical_design_geometric_presentation_representation', + 'organization', + 'organization_relationship', + 'organizational_project', + 'person_and_organization', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_association', + 'product_concept_feature_category', + 'product_concept_feature_category_usage', + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_relationship', + 'product_definition_substitute', + 'property_definition', + 'requirement_for_action_resource', + 'resource_property', + 'security_classification', + 'security_classification_level', + 'shape_representation', + 'versioned_action_request', + scope = schema_scope) +# Defined datatype presentable_text +class presentable_text(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = control_characters_free(self) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE product_or_formation_or_definition +product_or_formation_or_definition = SELECT( + 'product', + 'product_definition_formation', + 'product_definition', + scope = schema_scope) +# Defined datatype time_measure +class time_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE curve_on_surface +curve_on_surface = SELECT( + 'pcurve', + 'surface_curve', + 'composite_curve_on_surface', + scope = schema_scope) +# SELECT TYPE trimming_select +trimming_select = SELECT( + 'cartesian_point', + 'parameter_value', + scope = schema_scope) +# SELECT TYPE curve_style_font_select +curve_style_font_select = SELECT( + 'curve_style_font', + 'pre_defined_curve_font', + 'externally_defined_curve_font', + scope = schema_scope) +# SELECT TYPE role_select +role_select = SELECT( + 'action_assignment', + 'action_request_assignment', + 'approval_assignment', + 'approval_date_time', + 'certification_assignment', + 'contract_assignment', + 'document_reference', + 'effectivity_assignment', + 'group_assignment', + 'name_assignment', + 'security_classification_assignment', + scope = schema_scope) +# Defined datatype ahead_or_behind +class ahead_or_behind(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype mass_measure +class mass_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE tolerance_parameter_select +tolerance_parameter_select = SELECT( + 'curve_tolerance_parameter', + 'surface_tolerance_parameter', + scope = schema_scope) +# Defined datatype angle_relator +class angle_relator(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE characterized_action_definition +characterized_action_definition = SELECT( + 'action', + 'action_method', + 'action_method_relationship', + 'action_relationship', + scope = schema_scope) +# SELECT TYPE tolerance_method_definition +tolerance_method_definition = SELECT( + 'tolerance_value', + 'limits_and_fits', + scope = schema_scope) +# SELECT TYPE group_item +group_item = SELECT( + 'geometric_representation_item', + 'mapped_item', + 'product_concept_feature', + 'shape_aspect', + 'styled_item', + 'topological_representation_item', + scope = schema_scope) +# SELECT TYPE plane_or_planar_box +plane_or_planar_box = SELECT( + 'plane', + 'planar_box', + scope = schema_scope) +# Defined datatype positive_ratio_measure +class positive_ratio_measure(ratio_measure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE time_interval_item +time_interval_item = SELECT( + 'action', + 'action_directive', + 'action_method', + 'action_property', + 'action_relationship', + 'action_request_solution', + 'alternate_product_relationship', + 'applied_action_assignment', + 'applied_classification_assignment', + 'applied_person_and_organization_assignment', + 'approval_status', + 'assembly_component_usage_substitute', + 'certification', + 'class_', + 'class_system', + 'configuration_design', + 'configuration_effectivity', + 'configuration_item', + 'configured_effectivity_assignment', + 'contract', + 'document_file', + 'draughting_model', + 'drawing_revision', + 'executed_action', + 'general_property', + 'material_designation', + 'mechanical_design_geometric_presentation_representation', + 'organization_relationship', + 'organizational_project', + 'person_and_organization', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_association', + 'product_concept_feature_category', + 'product_concept_feature_category_usage', + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_relationship', + 'product_definition_substitute', + 'property_definition', + 'requirement_for_action_resource', + 'resource_property', + 'security_classification', + 'security_classification_level', + 'shape_representation', + 'versioned_action_request', + scope = schema_scope) +# SELECT TYPE character_spacing_select +character_spacing_select = SELECT( + 'length_measure', + 'ratio_measure', + 'measure_with_unit', + 'descriptive_measure', + scope = schema_scope) +# Defined datatype surface_tolerance_deviation +class surface_tolerance_deviation(positive_length_measure): + def __init__(self,*kargs): + pass + +# Defined datatype shading_curve_method +class shading_curve_method(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE description_attribute_select +description_attribute_select = SELECT( + 'action_request_solution', + 'application_context', + 'approval_role', + 'configuration_design', + 'date_role', + 'date_time_role', + 'context_dependent_shape_representation', + 'effectivity', + 'external_source', + 'organization_role', + 'person_and_organization_role', + 'person_and_organization', + 'property_definition_representation', + 'representation', + scope = schema_scope) +# Defined datatype descriptive_measure +class descriptive_measure(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype area_measure +class area_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE characterized_resource_definition +characterized_resource_definition = SELECT( + 'action_resource', + 'action_resource_requirement', + scope = schema_scope) +# Defined datatype text_alignment +class text_alignment(label): + def __init__(self,*kargs): + pass + +# SELECT TYPE kinematic_result +kinematic_result = SELECT( + 'interpolated_configuration_sequence', + 'resulting_path', + scope = schema_scope) +# Defined datatype month_in_year_number +class month_in_year_number(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((1 <= self) and (self <= 12)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype box_height +class box_height(positive_ratio_measure): + def __init__(self,*kargs): + pass + +# SELECT TYPE curve_or_render +curve_or_render = SELECT( + 'curve_style', + 'curve_style_rendering', + scope = schema_scope) +# Defined datatype source +class source(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE name_attribute_select +name_attribute_select = SELECT( + 'action_request_solution', + 'address', + 'configuration_design', + 'context_dependent_shape_representation', + 'derived_unit', + 'effectivity', + 'person_and_organization', + 'product_definition', + 'product_definition_substitute', + 'property_definition_representation', + scope = schema_scope) +# SELECT TYPE unit +unit = SELECT( + 'derived_unit', + 'named_unit', + scope = schema_scope) +# SELECT TYPE characterized_material_property +characterized_material_property = SELECT( + 'material_property_representation', + scope = schema_scope) +# SELECT TYPE date_item +date_item = SELECT( + 'action', + 'action_directive', + 'action_method', + 'action_property', + 'action_relationship', + 'action_request_solution', + 'alternate_product_relationship', + 'applied_action_assignment', + 'applied_classification_assignment', + 'applied_organization_assignment', + 'applied_person_and_organization_assignment', + 'approval_person_organization', + 'approval_status', + 'assembly_component_usage_substitute', + 'certification', + 'class_', + 'class_system', + 'configuration_design', + 'configuration_item', + 'configured_effectivity_assignment', + 'contract', + 'document_file', + 'draughting_model', + 'drawing_revision', + 'effectivity', + 'event_occurrence', + 'executed_action', + 'general_property', + 'material_designation', + 'mechanical_design_geometric_presentation_representation', + 'organization_relationship', + 'organizational_project', + 'person_and_organization', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_association', + 'product_concept_feature_category', + 'product_concept_feature_category_usage', + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_relationship', + 'product_definition_substitute', + 'property_definition', + 'requirement_for_action_resource', + 'resource_property', + 'security_classification', + 'security_classification_level', + 'shape_representation', + 'versioned_action_request', + scope = schema_scope) +# SELECT TYPE reversible_topology +reversible_topology = SELECT( + 'reversible_topology_item', + 'list_of_reversible_topology_item', + 'set_of_reversible_topology_item', + scope = schema_scope) +# SELECT TYPE shape_definition +shape_definition = SELECT( + 'product_definition_shape', + 'shape_aspect', + 'shape_aspect_relationship', + scope = schema_scope) +# Defined datatype celsius_temperature_measure +class celsius_temperature_measure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype second_in_minute +class second_in_minute(REAL): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self <= 60)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE annotation_text_occurrence_item +annotation_text_occurrence_item = SELECT( + 'text_literal', + 'annotation_text', + 'annotation_text_character', + 'defined_character_glyph', + 'composite_text', + scope = schema_scope) +# Defined datatype label +class label(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype context_dependent_measure +class context_dependent_measure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE supported_item +supported_item = SELECT( + 'action_directive', + 'action', + 'action_method', + scope = schema_scope) +# SELECT TYPE tolerance_select +tolerance_select = SELECT( + 'approximation_tolerance_deviation', + 'approximation_tolerance_parameter', + scope = schema_scope) +# Defined datatype boolean_operator +class boolean_operator(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE organizational_project_item +organizational_project_item = SELECT( + 'assembly_component_usage', + 'configuration_item', + 'executed_action', + 'product', + 'product_concept', + 'product_definition', + 'product_definition_formation', + scope = schema_scope) +# SELECT TYPE person_and_organization_item +person_and_organization_item = SELECT( + 'action', + 'action_directive', + 'action_method', + 'action_property', + 'action_relationship', + 'action_request_solution', + 'alternate_product_relationship', + 'applied_action_assignment', + 'applied_classification_assignment', + 'applied_organization_assignment', + 'applied_person_and_organization_assignment', + 'approval_status', + 'assembly_component_usage_substitute', + 'certification', + 'class_', + 'class_system', + 'configuration_design', + 'configuration_effectivity', + 'configuration_item', + 'configured_effectivity_assignment', + 'contract', + 'document_file', + 'document_type', + 'draughting_model', + 'drawing_revision', + 'event_occurrence', + 'executed_action', + 'general_property', + 'material_designation', + 'mechanical_design_geometric_presentation_representation', + 'organization', + 'organization_relationship', + 'organizational_project', + 'person_and_organization', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_association', + 'product_concept_feature_category', + 'product_concept_feature_category_usage', + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_relationship', + 'product_definition_substitute', + 'property_definition', + 'requirement_for_action_resource', + 'resource_property', + 'security_classification', + 'security_classification_level', + 'shape_representation', + 'versioned_action_request', + scope = schema_scope) +# SELECT TYPE box_characteristic_select +box_characteristic_select = SELECT( + 'box_height', + 'box_width', + 'box_slant_angle', + 'box_rotate_angle', + scope = schema_scope) +# Defined datatype si_prefix +class si_prefix(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE certification_item +certification_item = SELECT( + 'product_definition', + 'product_definition_formation', + 'product_definition_formation_relationship', + 'product_definition_relationship', + scope = schema_scope) +# SELECT TYPE fill_style_select +fill_style_select = SELECT( + 'fill_area_style_colour', + 'externally_defined_tile_style', + 'fill_area_style_tiles', + 'externally_defined_hatch_style', + 'fill_area_style_hatching', + scope = schema_scope) +# SELECT TYPE value_qualifier +value_qualifier = SELECT( + 'precision_qualifier', + 'type_qualifier', + 'uncertainty_qualifier', + scope = schema_scope) +# Defined datatype ypr_enumeration +class ypr_enumeration(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype interpolation_type +class interpolation_type(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype length_measure +class length_measure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype count_measure +class count_measure(NUMBER): + def __init__(self,*kargs): + pass + +# SELECT TYPE annotation_plane_element +annotation_plane_element = SELECT( + 'draughting_callout', + 'styled_item', + scope = schema_scope) +# SELECT TYPE rigid_placement +rigid_placement = SELECT( + 'axis2_placement_3d', + scope = schema_scope) +# SELECT TYPE identification_item +identification_item = SELECT( + 'action', + 'action_directive', + 'action_method', + 'action_property', + 'applied_identification_assignment', + 'approval_status', + 'class_', + 'class_system', + 'configuration_item', + 'dimensional_size', + 'document_file', + 'document_type', + 'draughting_model', + 'effectivity', + 'general_property', + 'measure_representation_item', + 'mechanical_design_geometric_presentation_representation', + 'organization', + 'organizational_project', + 'person_and_organization', + 'presentation_area', + 'product', + 'product_concept', + 'product_concept_feature', + 'product_concept_feature_category', + 'product_definition', + 'product_definition_formation', + 'product_definition_relationship', + 'property_definition', + 'property_definition_relationship', + 'security_classification_level', + 'shape_aspect_relationship', + 'shape_representation', + 'versioned_action_request', + scope = schema_scope) +# SELECT TYPE direction_count_select +direction_count_select = SELECT( + 'u_direction_count', + 'v_direction_count', + scope = schema_scope) +# Defined datatype product_or_presentation_space +class product_or_presentation_space(ENUMERATION): + def __init__(self,*kargs): + pass + +list_of_reversible_topology_item = LIST(0,None,'reversible_topology_item', scope = schema_scope) +# SELECT TYPE configuration_design_item +configuration_design_item = SELECT( + 'product_definition', + 'product_definition_formation', + scope = schema_scope) +# SELECT TYPE class_usage_effectivity_context_item +class_usage_effectivity_context_item = SELECT( + 'product_definition', + scope = schema_scope) +# SELECT TYPE surface_side_style_select +surface_side_style_select = SELECT( + 'surface_side_style', + scope = schema_scope) + +#################### + # ENTITY founded_item # +#################### +class founded_item(BaseEntityClass): + '''Entity founded_item definition. + + :param users + :type users:SET(0,None,'founded_item_select', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def users(): + def fget( self ): + attribute_eval = using_items(self,[]) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument users is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.users) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ( not (self == self.users)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY curve_style # +#################### +class curve_style(founded_item): + '''Entity curve_style definition. + + :param name + :type name:label + + :param curve_font + :type curve_font:curve_font_or_scaled_curve_font_select + + :param curve_width + :type curve_width:size_select + + :param curve_colour + :type curve_colour:colour + ''' + def __init__( self , name,curve_font,curve_width,curve_colour, ): + founded_item.__init__(self , ) + self.name = name + self.curve_font = curve_font + self.curve_width = curve_width + self.curve_colour = curve_colour + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def curve_font(): + def fget( self ): + return self._curve_font + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curve_font is mantatory and can not be set to None') + if not check_type(value,curve_font_or_scaled_curve_font_select): + self._curve_font = curve_font_or_scaled_curve_font_select(value) + else: + self._curve_font = value + return property(**locals()) + + @apply + def curve_width(): + def fget( self ): + return self._curve_width + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curve_width is mantatory and can not be set to None') + if not check_type(value,size_select): + self._curve_width = size_select(value) + else: + self._curve_width = value + return property(**locals()) + + @apply + def curve_colour(): + def fget( self ): + return self._curve_colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curve_colour is mantatory and can not be set to None') + if not check_type(value,colour): + self._curve_colour = colour(value) + else: + self._curve_colour = value + return property(**locals()) + +#################### + # ENTITY pair_value # +#################### +class pair_value(BaseEntityClass): + '''Entity pair_value definition. + + :param applies_to_pair + :type applies_to_pair:kinematic_pair + ''' + def __init__( self , applies_to_pair, ): + self.applies_to_pair = applies_to_pair + + @apply + def applies_to_pair(): + def fget( self ): + return self._applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applies_to_pair is mantatory and can not be set to None') + if not check_type(value,kinematic_pair): + self._applies_to_pair = kinematic_pair(value) + else: + self._applies_to_pair = value + return property(**locals()) + +#################### + # ENTITY point_on_surface_pair_value # +#################### +class point_on_surface_pair_value(pair_value): + '''Entity point_on_surface_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:point_on_surface_pair + + :param actual_point_on_surface + :type actual_point_on_surface:point_on_surface + + :param input_orientation + :type input_orientation:spatial_rotation + + :param actual_orientation + :type actual_orientation:ARRAY(ypr_index(yaw),ypr_index(roll),'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_point_on_surface,input_orientation, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_point_on_surface = actual_point_on_surface + self.input_orientation = input_orientation + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,point_on_surface_pair): + self._pair_value_applies_to_pair = point_on_surface_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_point_on_surface(): + def fget( self ): + return self._actual_point_on_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_point_on_surface is mantatory and can not be set to None') + if not check_type(value,point_on_surface): + self._actual_point_on_surface = point_on_surface(value) + else: + self._actual_point_on_surface = value + return property(**locals()) + + @apply + def input_orientation(): + def fget( self ): + return self._input_orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument input_orientation is mantatory and can not be set to None') + if not check_type(value,spatial_rotation): + self._input_orientation = spatial_rotation(value) + else: + self._input_orientation = value + return property(**locals()) + + @apply + def actual_orientation(): + def fget( self ): + attribute_eval = convert_spatial_to_ypr_rotation(self.self.pair_value.self.applies_to_pair,self.input_orientation) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument actual_orientation is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.pair_value.self.applies_to_pair.self.point_on_surface_pair.self.pair_surface == self.actual_point_on_surface.self.basis_surface) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY generic_expression # +#################### +class generic_expression(BaseEntityClass): + '''Entity generic_expression definition. + ''' + # This class does not define any attribute. + pass + def wr1(self): + eval_wr1_wr = is_acyclic(self) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY expression # +#################### +class expression(generic_expression): + '''Entity expression definition. + ''' + def __init__( self , ): + generic_expression.__init__(self , ) + +#################### + # ENTITY numeric_expression # +#################### +class numeric_expression(expression): + '''Entity numeric_expression definition. + + :param is_int + :type is_int:BOOLEAN + + :param sql_mappable + :type sql_mappable:BOOLEAN + ''' + def __init__( self , ): + expression.__init__(self , ) + + @apply + def is_int(): + def fget( self ): + attribute_eval = is_int_expr(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument is_int is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def sql_mappable(): + def fget( self ): + attribute_eval = is_sql_mappable(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument sql_mappable is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY simple_generic_expression # +#################### +class simple_generic_expression(generic_expression): + '''Entity simple_generic_expression definition. + ''' + def __init__( self , ): + generic_expression.__init__(self , ) + +#################### + # ENTITY simple_numeric_expression # +#################### +class simple_numeric_expression(numeric_expression,simple_generic_expression): + '''Entity simple_numeric_expression definition. + ''' + def __init__( self , ): + numeric_expression.__init__(self , ) + simple_generic_expression.__init__(self , ) + +#################### + # ENTITY generic_literal # +#################### +class generic_literal(simple_generic_expression): + '''Entity generic_literal definition. + ''' + def __init__( self , ): + simple_generic_expression.__init__(self , ) + +#################### + # ENTITY literal_number # +#################### +class literal_number(simple_numeric_expression,generic_literal): + '''Entity literal_number definition. + + :param the_value + :type the_value:(null) + ''' + def __init__( self , the_value, ): + simple_numeric_expression.__init__(self , ) + generic_literal.__init__(self , ) + self.the_value = the_value + + @apply + def the_value(): + def fget( self ): + return self._the_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument the_value is mantatory and can not be set to None') + if not check_type(value,(null)): + self._the_value = (null)(value) + else: + self._the_value = value + return property(**locals()) + +#################### + # ENTITY real_literal # +#################### +class real_literal(literal_number): + '''Entity real_literal definition. + + :param literal_number_the_value + :type literal_number_the_value:REAL + ''' + def __init__( self , inherited0__the_value , literal_number_the_value, ): + literal_number.__init__(self , inherited0__the_value , ) + self.literal_number_the_value = literal_number_the_value + + @apply + def literal_number_the_value(): + def fget( self ): + return self._literal_number_the_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument literal_number_the_value is mantatory and can not be set to None') + if not check_type(value,REAL): + self._literal_number_the_value = REAL(value) + else: + self._literal_number_the_value = value + return property(**locals()) + +#################### + # ENTITY representation_item # +#################### +class representation_item(BaseEntityClass): + '''Entity representation_item definition. + + :param name + :type name:label + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(using_representations(self)) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY styled_item # +#################### +class styled_item(representation_item): + '''Entity styled_item definition. + + :param styles + :type styles:SET(1,None,'presentation_style_assignment', scope = schema_scope) + + :param item + :type item:representation_item + ''' + def __init__( self , inherited0__name , styles,item, ): + representation_item.__init__(self , inherited0__name , ) + self.styles = styles + self.item = item + + @apply + def styles(): + def fget( self ): + return self._styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'presentation_style_assignment', scope = schema_scope)): + self._styles = SET(value) + else: + self._styles = value + return property(**locals()) + + @apply + def item(): + def fget( self ): + return self._item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item is mantatory and can not be set to None') + if not check_type(value,representation_item): + self._item = representation_item(value) + else: + self._item = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((SIZEOF(self.self.styles) == 1) XOR (SIZEOF(None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY annotation_occurrence # +#################### +class annotation_occurrence(styled_item): + '''Entity annotation_occurrence definition. + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , ): + styled_item.__init__(self , inherited0__name , inherited1__styles , inherited2__item , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.GEOMETRIC_REPRESENTATION_ITEM' == TYPEOF(self)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY annotation_fill_area_occurrence # +#################### +class annotation_fill_area_occurrence(annotation_occurrence): + '''Entity annotation_fill_area_occurrence definition. + + :param fill_style_target + :type fill_style_target:point + + :param styled_item_item + :type styled_item_item:annotation_fill_area + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , fill_style_target,styled_item_item, ): + annotation_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , ) + self.fill_style_target = fill_style_target + self.styled_item_item = styled_item_item + + @apply + def fill_style_target(): + def fget( self ): + return self._fill_style_target + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fill_style_target is mantatory and can not be set to None') + if not check_type(value,point): + self._fill_style_target = point(value) + else: + self._fill_style_target = value + return property(**locals()) + + @apply + def styled_item_item(): + def fget( self ): + return self._styled_item_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styled_item_item is mantatory and can not be set to None') + if not check_type(value,annotation_fill_area): + self._styled_item_item = annotation_fill_area(value) + else: + self._styled_item_item = value + return property(**locals()) + +#################### + # ENTITY characterized_object # +#################### +class characterized_object(BaseEntityClass): + '''Entity characterized_object definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY feature_definition # +#################### +class feature_definition(characterized_object): + '''Entity feature_definition definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + characterized_object.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(None) == 0) or (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not ((SIZEOF(['AUTOMOTIVE_DESIGN.' + 'BARRING_HOLE','AUTOMOTIVE_DESIGN.' + 'BEAD','AUTOMOTIVE_DESIGN.' + 'HOLE_IN_PANEL','AUTOMOTIVE_DESIGN.' + 'FEATURE_IN_PANEL','AUTOMOTIVE_DESIGN.' + 'JOGGLE','AUTOMOTIVE_DESIGN.' + 'LOCATOR'] * TYPEOF(self)) == 1) or ((('AUTOMOTIVE_DESIGN.' + 'COMPOUND_FEATURE') == TYPEOF(self)) and (SIZEOF(None) == 1)))) or ((SIZEOF(None) <= 1) and ((SIZEOF(None) == 0) or (SIZEOF(None) == 1)))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((SIZEOF(None) == 0) or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (( not ((SIZEOF(['AUTOMOTIVE_DESIGN.' + 'BOSS','AUTOMOTIVE_DESIGN.' + 'RIB','AUTOMOTIVE_DESIGN.' + 'SLOT','AUTOMOTIVE_DESIGN.' + 'ROUND_HOLE','AUTOMOTIVE_DESIGN.' + 'POCKET'] * TYPEOF(self)) == 1) or ((('AUTOMOTIVE_DESIGN.' + 'COMPOUND_FEATURE') == TYPEOF(self)) and (SIZEOF(None) == 1)))) or ((SIZEOF(None) == 1) and (SIZEOF(None) == 1))) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'BEAD','AUTOMOTIVE_DESIGN.' + 'BARRING_HOLE','AUTOMOTIVE_DESIGN.' + 'BOSS','AUTOMOTIVE_DESIGN.' + 'COMPOUND_FEATURE','AUTOMOTIVE_DESIGN.' + 'EXTERNALLY_DEFINED_FEATURE_DEFINITION','AUTOMOTIVE_DESIGN.' + 'FEATURE_IN_PANEL','AUTOMOTIVE_DESIGN.' + 'GENERAL_FEATURE','AUTOMOTIVE_DESIGN.' + 'HOLE_IN_PANEL','AUTOMOTIVE_DESIGN.' + 'JOGGLE','AUTOMOTIVE_DESIGN.' + 'LOCATOR','AUTOMOTIVE_DESIGN.' + 'POCKET','AUTOMOTIVE_DESIGN.' + 'RIB','AUTOMOTIVE_DESIGN.' + 'REPLICATE_FEATURE','AUTOMOTIVE_DESIGN.' + 'ROUND_HOLE','AUTOMOTIVE_DESIGN.' + 'SLOT','AUTOMOTIVE_DESIGN.' + 'THREAD'] * TYPEOF(self)) <= 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + +#################### + # ENTITY compound_feature # +#################### +class compound_feature(feature_definition): + '''Entity compound_feature definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((SIZEOF(None) + SIZEOF(None)) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY composite_hole # +#################### +class composite_hole(compound_feature): + '''Entity composite_hole definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + compound_feature.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (self.self.characterized_object.self.description == ['counterbore','countersunk']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'countersunk') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY identification_role # +#################### +class identification_role(BaseEntityClass): + '''Entity identification_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY certification_assignment # +#################### +class certification_assignment(BaseEntityClass): + '''Entity certification_assignment definition. + + :param assigned_certification + :type assigned_certification:certification + + :param role + :type role:object_role + ''' + def __init__( self , assigned_certification, ): + self.assigned_certification = assigned_certification + + @apply + def assigned_certification(): + def fget( self ): + return self._assigned_certification + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_certification is mantatory and can not be set to None') + if not check_type(value,certification): + self._assigned_certification = certification(value) + else: + self._assigned_certification = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_certification_assignment # +#################### +class applied_certification_assignment(certification_assignment): + '''Entity applied_certification_assignment definition. + + :param items + :type items:SET(1,None,'certification_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_certification , items, ): + certification_assignment.__init__(self , inherited0__assigned_certification , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'certification_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY geometric_representation_item # +#################### +class geometric_representation_item(representation_item): + '''Entity geometric_representation_item definition. + + :param dim + :type dim:dimension_count + ''' + def __init__( self , inherited0__name , ): + representation_item.__init__(self , inherited0__name , ) + + @apply + def dim(): + def fget( self ): + attribute_eval = dimension_of(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY functionally_defined_transformation # +#################### +class functionally_defined_transformation(BaseEntityClass): + '''Entity functionally_defined_transformation definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY cartesian_transformation_operator # +#################### +class cartesian_transformation_operator(geometric_representation_item,functionally_defined_transformation): + '''Entity cartesian_transformation_operator definition. + + :param axis1 + :type axis1:direction + + :param axis2 + :type axis2:direction + + :param local_origin + :type local_origin:cartesian_point + + :param scale + :type scale:REAL + + :param scl + :type scl:REAL + ''' + def __init__( self , inherited0__name , inherited1__name , inherited2__description , axis1,axis2,local_origin,scale, ): + geometric_representation_item.__init__(self , inherited0__name , ) + functionally_defined_transformation.__init__(self , inherited1__name , inherited2__description , ) + self.axis1 = axis1 + self.axis2 = axis2 + self.local_origin = local_origin + self.scale = scale + + @apply + def axis1(): + def fget( self ): + return self._axis1 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,direction): + self._axis1 = direction(value) + else: + self._axis1 = value + else: + self._axis1 = value + return property(**locals()) + + @apply + def axis2(): + def fget( self ): + return self._axis2 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,direction): + self._axis2 = direction(value) + else: + self._axis2 = value + else: + self._axis2 = value + return property(**locals()) + + @apply + def local_origin(): + def fget( self ): + return self._local_origin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument local_origin is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._local_origin = cartesian_point(value) + else: + self._local_origin = value + return property(**locals()) + + @apply + def scale(): + def fget( self ): + return self._scale + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._scale = REAL(value) + else: + self._scale = value + else: + self._scale = value + return property(**locals()) + + @apply + def scl(): + def fget( self ): + attribute_eval = NVL(self.scale,1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scl is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.scl > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY cartesian_transformation_operator_3d # +#################### +class cartesian_transformation_operator_3d(cartesian_transformation_operator): + '''Entity cartesian_transformation_operator_3d definition. + + :param axis3 + :type axis3:direction + + :param u + :type u:LIST(3,3,'direction', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__name , inherited2__description , inherited3__axis1 , inherited4__axis2 , inherited5__local_origin , inherited6__scale , axis3, ): + cartesian_transformation_operator.__init__(self , inherited0__name , inherited1__name , inherited2__description , inherited3__axis1 , inherited4__axis2 , inherited5__local_origin , inherited6__scale , ) + self.axis3 = axis3 + + @apply + def axis3(): + def fget( self ): + return self._axis3 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,direction): + self._axis3 = direction(value) + else: + self._axis3 = value + else: + self._axis3 = value + return property(**locals()) + + @apply + def u(): + def fget( self ): + attribute_eval = base_axis(3,self.self.cartesian_transformation_operator.self.axis1,self.self.cartesian_transformation_operator.self.axis2,self.axis3) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument u is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.geometric_representation_item.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY boolean_expression # +#################### +class boolean_expression(expression): + '''Entity boolean_expression definition. + ''' + def __init__( self , ): + expression.__init__(self , ) + +#################### + # ENTITY multiple_arity_generic_expression # +#################### +class multiple_arity_generic_expression(generic_expression): + '''Entity multiple_arity_generic_expression definition. + + :param operands + :type operands:LIST(2,None,'generic_expression', scope = schema_scope) + ''' + def __init__( self , operands, ): + generic_expression.__init__(self , ) + self.operands = operands + + @apply + def operands(): + def fget( self ): + return self._operands + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operands is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'generic_expression', scope = schema_scope)): + self._operands = LIST(value) + else: + self._operands = value + return property(**locals()) + +#################### + # ENTITY multiple_arity_boolean_expression # +#################### +class multiple_arity_boolean_expression(boolean_expression,multiple_arity_generic_expression): + '''Entity multiple_arity_boolean_expression definition. + + :param multiple_arity_generic_expression_operands + :type multiple_arity_generic_expression_operands:LIST(2,None,'boolean_expression', scope = schema_scope) + ''' + def __init__( self , inherited0__operands , multiple_arity_generic_expression_operands, ): + boolean_expression.__init__(self , ) + multiple_arity_generic_expression.__init__(self , inherited0__operands , ) + self.multiple_arity_generic_expression_operands = multiple_arity_generic_expression_operands + + @apply + def multiple_arity_generic_expression_operands(): + def fget( self ): + return self._multiple_arity_generic_expression_operands + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument multiple_arity_generic_expression_operands is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'boolean_expression', scope = schema_scope)): + self._multiple_arity_generic_expression_operands = LIST(value) + else: + self._multiple_arity_generic_expression_operands = value + return property(**locals()) + +#################### + # ENTITY or_expression # +#################### +class or_expression(multiple_arity_boolean_expression): + '''Entity or_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ): + multiple_arity_boolean_expression.__init__(self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ) + +#################### + # ENTITY versioned_action_request # +#################### +class versioned_action_request(BaseEntityClass): + '''Entity versioned_action_request definition. + + :param id + :type id:identifier + + :param version + :type version:label + + :param purpose + :type purpose:text + + :param description + :type description:text + ''' + def __init__( self , id,version,purpose,description, ): + self.id = id + self.version = version + self.purpose = purpose + self.description = description + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def version(): + def fget( self ): + return self._version + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument version is mantatory and can not be set to None') + if not check_type(value,label): + self._version = label(value) + else: + self._version = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument purpose is mantatory and can not be set to None') + if not check_type(value,text): + self._purpose = text(value) + else: + self._purpose = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY unary_generic_expression # +#################### +class unary_generic_expression(generic_expression): + '''Entity unary_generic_expression definition. + + :param operand + :type operand:generic_expression + ''' + def __init__( self , operand, ): + generic_expression.__init__(self , ) + self.operand = operand + + @apply + def operand(): + def fget( self ): + return self._operand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operand is mantatory and can not be set to None') + if not check_type(value,generic_expression): + self._operand = generic_expression(value) + else: + self._operand = value + return property(**locals()) + +#################### + # ENTITY unary_numeric_expression # +#################### +class unary_numeric_expression(numeric_expression,unary_generic_expression): + '''Entity unary_numeric_expression definition. + + :param unary_generic_expression_operand + :type unary_generic_expression_operand:numeric_expression + ''' + def __init__( self , inherited0__operand , unary_generic_expression_operand, ): + numeric_expression.__init__(self , ) + unary_generic_expression.__init__(self , inherited0__operand , ) + self.unary_generic_expression_operand = unary_generic_expression_operand + + @apply + def unary_generic_expression_operand(): + def fget( self ): + return self._unary_generic_expression_operand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unary_generic_expression_operand is mantatory and can not be set to None') + if not check_type(value,numeric_expression): + self._unary_generic_expression_operand = numeric_expression(value) + else: + self._unary_generic_expression_operand = value + return property(**locals()) + +#################### + # ENTITY unary_function_call # +#################### +class unary_function_call(unary_numeric_expression): + '''Entity unary_function_call definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_numeric_expression.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY asin_function # +#################### +class asin_function(unary_function_call): + '''Entity asin_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY geometric_tolerance # +#################### +class geometric_tolerance(BaseEntityClass): + '''Entity geometric_tolerance definition. + + :param name + :type name:label + + :param description + :type description:text + + :param magnitude + :type magnitude:measure_with_unit + + :param toleranced_shape_aspect + :type toleranced_shape_aspect:shape_aspect + ''' + def __init__( self , name,description,magnitude,toleranced_shape_aspect, ): + self.name = name + self.description = description + self.magnitude = magnitude + self.toleranced_shape_aspect = toleranced_shape_aspect + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def magnitude(): + def fget( self ): + return self._magnitude + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument magnitude is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._magnitude = measure_with_unit(value) + else: + self._magnitude = value + return property(**locals()) + + @apply + def toleranced_shape_aspect(): + def fget( self ): + return self._toleranced_shape_aspect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument toleranced_shape_aspect is mantatory and can not be set to None') + if not check_type(value,shape_aspect): + self._toleranced_shape_aspect = shape_aspect(value) + else: + self._toleranced_shape_aspect = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('NUMBER' == TYPEOF(self.magnitude.self.measure_with_unit.self.value_component)) and (self.magnitude.self.measure_with_unit.self.value_component >= 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY cylindricity_tolerance # +#################### +class cylindricity_tolerance(geometric_tolerance): + '''Entity cylindricity_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + def wr1(self): + eval_wr1_wr = ( not (('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE') == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY representation # +#################### +class representation(BaseEntityClass): + '''Entity representation definition. + + :param name + :type name:label + + :param items + :type items:SET(1,None,'representation_item', scope = schema_scope) + + :param context_of_items + :type context_of_items:representation_context + + :param id + :type id:identifier + + :param description + :type description:text + ''' + def __init__( self , name,items,context_of_items, ): + self.name = name + self.items = items + self.context_of_items = context_of_items + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'representation_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + + @apply + def context_of_items(): + def fget( self ): + return self._context_of_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument context_of_items is mantatory and can not be set to None') + if not check_type(value,representation_context): + self._context_of_items = representation_context(value) + else: + self._context_of_items = value + return property(**locals()) + + @apply + def id(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument id is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY shape_representation # +#################### +class shape_representation(representation): + '''Entity shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + +#################### + # ENTITY manifold_surface_shape_representation # +#################### +class manifold_surface_shape_representation(shape_representation): + '''Entity manifold_surface_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 0) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 0) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) == 0) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(None) == 0) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = (SIZEOF(None) == 0) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + def wr14(self): + eval_wr14_wr = (SIZEOF(None) == 0) + if not eval_wr14_wr: + raise AssertionError('Rule wr14 violated') + else: + return eval_wr14_wr + + +#################### + # ENTITY simple_pair_range # +#################### +class simple_pair_range(BaseEntityClass): + '''Entity simple_pair_range definition. + + :param applies_to_pair + :type applies_to_pair:kinematic_pair + ''' + def __init__( self , applies_to_pair, ): + self.applies_to_pair = applies_to_pair + + @apply + def applies_to_pair(): + def fget( self ): + return self._applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applies_to_pair is mantatory and can not be set to None') + if not check_type(value,kinematic_pair): + self._applies_to_pair = kinematic_pair(value) + else: + self._applies_to_pair = value + return property(**locals()) + +#################### + # ENTITY planar_curve_pair_range # +#################### +class planar_curve_pair_range(simple_pair_range): + '''Entity planar_curve_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:planar_curve_pair + + :param range_on_curve_1 + :type range_on_curve_1:trimmed_curve + + :param range_on_curve_2 + :type range_on_curve_2:trimmed_curve + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,range_on_curve_1,range_on_curve_2, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.range_on_curve_1 = range_on_curve_1 + self.range_on_curve_2 = range_on_curve_2 + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,planar_curve_pair): + self._simple_pair_range_applies_to_pair = planar_curve_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def range_on_curve_1(): + def fget( self ): + return self._range_on_curve_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument range_on_curve_1 is mantatory and can not be set to None') + if not check_type(value,trimmed_curve): + self._range_on_curve_1 = trimmed_curve(value) + else: + self._range_on_curve_1 = value + return property(**locals()) + + @apply + def range_on_curve_2(): + def fget( self ): + return self._range_on_curve_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument range_on_curve_2 is mantatory and can not be set to None') + if not check_type(value,trimmed_curve): + self._range_on_curve_2 = trimmed_curve(value) + else: + self._range_on_curve_2 = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.simple_pair_range.self.applies_to_pair.self.planar_curve_pair.self.curve_1 == self.range_on_curve_1.self.basis_curve) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.simple_pair_range.self.applies_to_pair.self.planar_curve_pair.self.curve_2 == self.range_on_curve_2.self.basis_curve) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY certification # +#################### +class certification(BaseEntityClass): + '''Entity certification definition. + + :param name + :type name:label + + :param purpose + :type purpose:text + + :param kind + :type kind:certification_type + ''' + def __init__( self , name,purpose,kind, ): + self.name = name + self.purpose = purpose + self.kind = kind + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument purpose is mantatory and can not be set to None') + if not check_type(value,text): + self._purpose = text(value) + else: + self._purpose = value + return property(**locals()) + + @apply + def kind(): + def fget( self ): + return self._kind + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument kind is mantatory and can not be set to None') + if not check_type(value,certification_type): + self._kind = certification_type(value) + else: + self._kind = value + return property(**locals()) + +#################### + # ENTITY mechanical_design_geometric_presentation_representation # +#################### +class mechanical_design_geometric_presentation_representation(representation): + '''Entity mechanical_design_geometric_presentation_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 0) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 0) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) == 0) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(None) == 0) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = (SIZEOF(None) == 0) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + def wr14(self): + eval_wr14_wr = (SIZEOF(None) == 0) + if not eval_wr14_wr: + raise AssertionError('Rule wr14 violated') + else: + return eval_wr14_wr + + +#################### + # ENTITY camera_model # +#################### +class camera_model(geometric_representation_item): + '''Entity camera_model definition. + ''' + def __init__( self , inherited0__name , ): + geometric_representation_item.__init__(self , inherited0__name , ) + def wr1(self): + eval_wr1_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ITEM_DEFINED_TRANSFORMATION.TRANSFORM_ITEM_1')) + SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.REPRESENTATION_MAP.MAPPING_ORIGIN'))) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.STYLED_ITEM.ITEM')) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY product_definition_relationship # +#################### +class product_definition_relationship(BaseEntityClass): + '''Entity product_definition_relationship definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + + :param relating_product_definition + :type relating_product_definition:product_definition + + :param related_product_definition + :type related_product_definition:product_definition + ''' + def __init__( self , id,name,description,relating_product_definition,related_product_definition, ): + self.id = id + self.name = name + self.description = description + self.relating_product_definition = relating_product_definition + self.related_product_definition = related_product_definition + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_product_definition(): + def fget( self ): + return self._relating_product_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_product_definition is mantatory and can not be set to None') + if not check_type(value,product_definition): + self._relating_product_definition = product_definition(value) + else: + self._relating_product_definition = value + return property(**locals()) + + @apply + def related_product_definition(): + def fget( self ): + return self._related_product_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_product_definition is mantatory and can not be set to None') + if not check_type(value,product_definition): + self._related_product_definition = product_definition(value) + else: + self._related_product_definition = value + return property(**locals()) + +#################### + # ENTITY product_definition_usage # +#################### +class product_definition_usage(product_definition_relationship): + '''Entity product_definition_usage definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , ): + product_definition_relationship.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , ) + def wr1(self): + eval_wr1_wr = acyclic_product_definition_relationship(self,[self.self.product_definition_relationship.self.related_product_definition],'AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_USAGE') + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY assembly_component_usage # +#################### +class assembly_component_usage(product_definition_usage): + '''Entity assembly_component_usage definition. + + :param reference_designator + :type reference_designator:identifier + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , reference_designator, ): + product_definition_usage.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , ) + self.reference_designator = reference_designator + + @apply + def reference_designator(): + def fget( self ): + return self._reference_designator + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,identifier): + self._reference_designator = identifier(value) + else: + self._reference_designator = value + else: + self._reference_designator = value + return property(**locals()) + +#################### + # ENTITY quantified_assembly_component_usage # +#################### +class quantified_assembly_component_usage(assembly_component_usage): + '''Entity quantified_assembly_component_usage definition. + + :param quantity + :type quantity:measure_with_unit + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , inherited5__reference_designator , quantity, ): + assembly_component_usage.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , inherited5__reference_designator , ) + self.quantity = quantity + + @apply + def quantity(): + def fget( self ): + return self._quantity + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument quantity is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._quantity = measure_with_unit(value) + else: + self._quantity = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not ('NUMBER' == TYPEOF(self.quantity.self.value_component))) or (self.quantity.self.value_component > 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY generic_variable # +#################### +class generic_variable(simple_generic_expression): + '''Entity generic_variable definition. + + :param interpretation + :type interpretation:environment + ''' + def __init__( self , ): + simple_generic_expression.__init__(self , ) + + @apply + def interpretation(): + def fget( self ): + return self._interpretation + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument interpretation is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY variable # +#################### +class variable(generic_variable): + '''Entity variable definition. + ''' + def __init__( self , ): + generic_variable.__init__(self , ) + +#################### + # ENTITY numeric_variable # +#################### +class numeric_variable(simple_numeric_expression,variable): + '''Entity numeric_variable definition. + ''' + def __init__( self , ): + simple_numeric_expression.__init__(self , ) + variable.__init__(self , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.INT_NUMERIC_VARIABLE' == TYPEOF(self)) or ('AUTOMOTIVE_DESIGN.REAL_NUMERIC_VARIABLE' == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY real_numeric_variable # +#################### +class real_numeric_variable(numeric_variable): + '''Entity real_numeric_variable definition. + ''' + def __init__( self , ): + numeric_variable.__init__(self , ) + +#################### + # ENTITY draughting_model # +#################### +class draughting_model(representation): + '''Entity draughting_model definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY externally_defined_item # +#################### +class externally_defined_item(BaseEntityClass): + '''Entity externally_defined_item definition. + + :param item_id + :type item_id:source_item + + :param source + :type source:external_source + ''' + def __init__( self , item_id,source, ): + self.item_id = item_id + self.source = source + + @apply + def item_id(): + def fget( self ): + return self._item_id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_id is mantatory and can not be set to None') + if not check_type(value,source_item): + self._item_id = source_item(value) + else: + self._item_id = value + return property(**locals()) + + @apply + def source(): + def fget( self ): + return self._source + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument source is mantatory and can not be set to None') + if not check_type(value,external_source): + self._source = external_source(value) + else: + self._source = value + return property(**locals()) + +#################### + # ENTITY externally_defined_hatch_style # +#################### +class externally_defined_hatch_style(externally_defined_item,geometric_representation_item): + '''Entity externally_defined_hatch_style definition. + ''' + def __init__( self , inherited0__item_id , inherited1__source , inherited2__name , ): + externally_defined_item.__init__(self , inherited0__item_id , inherited1__source , ) + geometric_representation_item.__init__(self , inherited2__name , ) + +#################### + # ENTITY solid_model # +#################### +class solid_model(geometric_representation_item): + '''Entity solid_model definition. + ''' + def __init__( self , inherited0__name , ): + geometric_representation_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY manifold_solid_brep # +#################### +class manifold_solid_brep(solid_model): + '''Entity manifold_solid_brep definition. + + :param outer + :type outer:closed_shell + ''' + def __init__( self , inherited0__name , outer, ): + solid_model.__init__(self , inherited0__name , ) + self.outer = outer + + @apply + def outer(): + def fget( self ): + return self._outer + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument outer is mantatory and can not be set to None') + if not check_type(value,closed_shell): + self._outer = closed_shell(value) + else: + self._outer = value + return property(**locals()) + +#################### + # ENTITY faceted_brep # +#################### +class faceted_brep(manifold_solid_brep): + '''Entity faceted_brep definition. + ''' + def __init__( self , inherited0__name , inherited1__outer , ): + manifold_solid_brep.__init__(self , inherited0__name , inherited1__outer , ) + +#################### + # ENTITY action_resource # +#################### +class action_resource(BaseEntityClass): + '''Entity action_resource definition. + + :param name + :type name:label + + :param description + :type description:text + + :param usage + :type usage:SET(1,None,'supported_item', scope = schema_scope) + + :param kind + :type kind:action_resource_type + ''' + def __init__( self , name,description,usage,kind, ): + self.name = name + self.description = description + self.usage = usage + self.kind = kind + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def usage(): + def fget( self ): + return self._usage + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument usage is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'supported_item', scope = schema_scope)): + self._usage = SET(value) + else: + self._usage = value + return property(**locals()) + + @apply + def kind(): + def fget( self ): + return self._kind + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument kind is mantatory and can not be set to None') + if not check_type(value,action_resource_type): + self._kind = action_resource_type(value) + else: + self._kind = value + return property(**locals()) + +#################### + # ENTITY product_definition # +#################### +class product_definition(BaseEntityClass): + '''Entity product_definition definition. + + :param id + :type id:identifier + + :param description + :type description:text + + :param formation + :type formation:product_definition_formation + + :param frame_of_reference + :type frame_of_reference:product_definition_context + + :param name + :type name:label + ''' + def __init__( self , id,description,formation,frame_of_reference, ): + self.id = id + self.description = description + self.formation = formation + self.frame_of_reference = frame_of_reference + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def formation(): + def fget( self ): + return self._formation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument formation is mantatory and can not be set to None') + if not check_type(value,product_definition_formation): + self._formation = product_definition_formation(value) + else: + self._formation = value + return property(**locals()) + + @apply + def frame_of_reference(): + def fget( self ): + return self._frame_of_reference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument frame_of_reference is mantatory and can not be set to None') + if not check_type(value,product_definition_context): + self._frame_of_reference = product_definition_context(value) + else: + self._frame_of_reference = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_definition_resource # +#################### +class product_definition_resource(action_resource,product_definition): + '''Entity product_definition_resource definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__usage , inherited3__kind , inherited4__id , inherited5__description , inherited6__formation , inherited7__frame_of_reference , ): + action_resource.__init__(self , inherited0__name , inherited1__description , inherited2__usage , inherited3__kind , ) + product_definition.__init__(self , inherited4__id , inherited5__description , inherited6__formation , inherited7__frame_of_reference , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.REQUIREMENT_FOR_ACTION_RESOURCE.RESOURCES')) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.frame_of_reference.self.name == ['part_definition','part occurrence','physical occurrence']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY resource_property_representation # +#################### +class resource_property_representation(BaseEntityClass): + '''Entity resource_property_representation definition. + + :param name + :type name:label + + :param description + :type description:text + + :param property + :type property:resource_property + + :param representation + :type representation:representation + ''' + def __init__( self , name,description,property,representation, ): + self.name = name + self.description = description + self.property = property + self.representation = representation + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def property(): + def fget( self ): + return self._property + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument property is mantatory and can not be set to None') + if not check_type(value,resource_property): + self._property = resource_property(value) + else: + self._property = value + return property(**locals()) + + @apply + def representation(): + def fget( self ): + return self._representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation is mantatory and can not be set to None') + if not check_type(value,representation): + self._representation = representation(value) + else: + self._representation = value + return property(**locals()) + +#################### + # ENTITY time_interval # +#################### +class time_interval(BaseEntityClass): + '''Entity time_interval definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , id,name,description, ): + self.id = id + self.name = name + self.description = description + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY time_interval_with_bounds # +#################### +class time_interval_with_bounds(time_interval): + '''Entity time_interval_with_bounds definition. + + :param primary_bound + :type primary_bound:date_time_or_event_occurrence + + :param secondary_bound + :type secondary_bound:date_time_or_event_occurrence + + :param duration + :type duration:time_measure_with_unit + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , primary_bound,secondary_bound,duration, ): + time_interval.__init__(self , inherited0__id , inherited1__name , inherited2__description , ) + self.primary_bound = primary_bound + self.secondary_bound = secondary_bound + self.duration = duration + + @apply + def primary_bound(): + def fget( self ): + return self._primary_bound + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,date_time_or_event_occurrence): + self._primary_bound = date_time_or_event_occurrence(value) + else: + self._primary_bound = value + else: + self._primary_bound = value + return property(**locals()) + + @apply + def secondary_bound(): + def fget( self ): + return self._secondary_bound + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,date_time_or_event_occurrence): + self._secondary_bound = date_time_or_event_occurrence(value) + else: + self._secondary_bound = value + else: + self._secondary_bound = value + return property(**locals()) + + @apply + def duration(): + def fget( self ): + return self._duration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,time_measure_with_unit): + self._duration = time_measure_with_unit(value) + else: + self._duration = value + else: + self._duration = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not (EXISTS(self.secondary_bound) and EXISTS(self.duration))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (EXISTS(self.primary_bound) or EXISTS(self.secondary_bound)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY action_directive # +#################### +class action_directive(BaseEntityClass): + '''Entity action_directive definition. + + :param name + :type name:label + + :param description + :type description:text + + :param analysis + :type analysis:text + + :param comment + :type comment:text + + :param requests + :type requests:SET(1,None,'versioned_action_request', scope = schema_scope) + ''' + def __init__( self , name,description,analysis,comment,requests, ): + self.name = name + self.description = description + self.analysis = analysis + self.comment = comment + self.requests = requests + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def analysis(): + def fget( self ): + return self._analysis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument analysis is mantatory and can not be set to None') + if not check_type(value,text): + self._analysis = text(value) + else: + self._analysis = value + return property(**locals()) + + @apply + def comment(): + def fget( self ): + return self._comment + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument comment is mantatory and can not be set to None') + if not check_type(value,text): + self._comment = text(value) + else: + self._comment = value + return property(**locals()) + + @apply + def requests(): + def fget( self ): + return self._requests + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument requests is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'versioned_action_request', scope = schema_scope)): + self._requests = SET(value) + else: + self._requests = value + return property(**locals()) + +#################### + # ENTITY event_occurrence_context_role # +#################### +class event_occurrence_context_role(BaseEntityClass): + '''Entity event_occurrence_context_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY shape_aspect # +#################### +class shape_aspect(BaseEntityClass): + '''Entity shape_aspect definition. + + :param name + :type name:label + + :param description + :type description:text + + :param of_shape + :type of_shape:product_definition_shape + + :param product_definitional + :type product_definitional:LOGICAL + + :param id + :type id:identifier + ''' + def __init__( self , name,description,of_shape,product_definitional, ): + self.name = name + self.description = description + self.of_shape = of_shape + self.product_definitional = product_definitional + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def of_shape(): + def fget( self ): + return self._of_shape + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument of_shape is mantatory and can not be set to None') + if not check_type(value,product_definition_shape): + self._of_shape = product_definition_shape(value) + else: + self._of_shape = value + return property(**locals()) + + @apply + def product_definitional(): + def fget( self ): + return self._product_definitional + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument product_definitional is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._product_definitional = LOGICAL(value) + else: + self._product_definitional = value + return property(**locals()) + + @apply + def id(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument id is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY hole_bottom # +#################### +class hole_bottom(shape_aspect): + '''Entity hole_bottom definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.description == ['through','flat','flat with taper','flat with radius','spherical','conical']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not (self.self.description == ['through','flat'])) or (SIZEOF(get_shape_aspect_property_definition_representations(self)) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (self.self.description == ['flat with radius','flat with taper','spherical','conical'])) or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'flat with taper') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'conical') or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (( not (self.self.description == ['flat with radius','spherical'])) or (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((self.self.description != 'flat with radius') or (SIZEOF(None) == 1)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = ((self.self.description != 'spherical') or (SIZEOF(None) == 1)) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = ((self.self.description != 'conical') or (SIZEOF(None) == 1)) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = ((self.self.description != 'conical') or (SIZEOF(None) == 1)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = ((self.self.description != 'flat with taper') or (SIZEOF(None) == 1)) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = ((self.self.description != 'flat with taper') or (SIZEOF(None) == 1)) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + def wr14(self): + eval_wr14_wr = (SIZEOF(None) == 1) + if not eval_wr14_wr: + raise AssertionError('Rule wr14 violated') + else: + return eval_wr14_wr + + def wr15(self): + eval_wr15_wr = ((self.self.description == 'through') or (SIZEOF(None) == 1)) + if not eval_wr15_wr: + raise AssertionError('Rule wr15 violated') + else: + return eval_wr15_wr + + +#################### + # ENTITY named_unit # +#################### +class named_unit(BaseEntityClass): + '''Entity named_unit definition. + + :param dimensions + :type dimensions:dimensional_exponents + ''' + def __init__( self , dimensions, ): + self.dimensions = dimensions + + @apply + def dimensions(): + def fget( self ): + return self._dimensions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dimensions is mantatory and can not be set to None') + if not check_type(value,dimensional_exponents): + self._dimensions = dimensional_exponents(value) + else: + self._dimensions = value + return property(**locals()) + +#################### + # ENTITY plane_angle_unit # +#################### +class plane_angle_unit(named_unit): + '''Entity plane_angle_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 0) and (self.self.named_unit.self.dimensions.self.mass_exponent == 0)) and (self.self.named_unit.self.dimensions.self.time_exponent == 0)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 0)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 0)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 0)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY configuration_definition # +#################### +class configuration_definition(BaseEntityClass): + '''Entity configuration_definition definition. + + :param pair_values + :type pair_values:SET(1,None,'pair_value', scope = schema_scope) + + :param t_parameter + :type t_parameter:motion_parameter_measure + ''' + def __init__( self , pair_values,t_parameter, ): + self.pair_values = pair_values + self.t_parameter = t_parameter + + @apply + def pair_values(): + def fget( self ): + return self._pair_values + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_values is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'pair_value', scope = schema_scope)): + self._pair_values = SET(value) + else: + self._pair_values = value + return property(**locals()) + + @apply + def t_parameter(): + def fget( self ): + return self._t_parameter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument t_parameter is mantatory and can not be set to None') + if not check_type(value,motion_parameter_measure): + self._t_parameter = motion_parameter_measure(value) + else: + self._t_parameter = value + return property(**locals()) + +#################### + # ENTITY annotation_symbol_occurrence # +#################### +class annotation_symbol_occurrence(annotation_occurrence): + '''Entity annotation_symbol_occurrence definition. + + :param styled_item_item + :type styled_item_item:annotation_symbol_occurrence_item + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , styled_item_item, ): + annotation_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , ) + self.styled_item_item = styled_item_item + + @apply + def styled_item_item(): + def fget( self ): + return self._styled_item_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styled_item_item is mantatory and can not be set to None') + if not check_type(value,annotation_symbol_occurrence_item): + self._styled_item_item = annotation_symbol_occurrence_item(value) + else: + self._styled_item_item = value + return property(**locals()) + +#################### + # ENTITY terminator_symbol # +#################### +class terminator_symbol(annotation_symbol_occurrence): + '''Entity terminator_symbol definition. + + :param annotated_curve + :type annotated_curve:annotation_curve_occurrence + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , annotated_curve, ): + annotation_symbol_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , ) + self.annotated_curve = annotated_curve + + @apply + def annotated_curve(): + def fget( self ): + return self._annotated_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument annotated_curve is mantatory and can not be set to None') + if not check_type(value,annotation_curve_occurrence): + self._annotated_curve = annotation_curve_occurrence(value) + else: + self._annotated_curve = value + return property(**locals()) + +#################### + # ENTITY leader_terminator # +#################### +class leader_terminator(terminator_symbol): + '''Entity leader_terminator definition. + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , inherited4__annotated_curve , ): + terminator_symbol.__init__(self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , inherited4__annotated_curve , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.LEADER_CURVE' == TYPEOF(self.self.terminator_symbol.self.annotated_curve)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY shape_aspect_relationship # +#################### +class shape_aspect_relationship(BaseEntityClass): + '''Entity shape_aspect_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_shape_aspect + :type relating_shape_aspect:shape_aspect + + :param related_shape_aspect + :type related_shape_aspect:shape_aspect + + :param id + :type id:identifier + ''' + def __init__( self , name,description,relating_shape_aspect,related_shape_aspect, ): + self.name = name + self.description = description + self.relating_shape_aspect = relating_shape_aspect + self.related_shape_aspect = related_shape_aspect + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_shape_aspect(): + def fget( self ): + return self._relating_shape_aspect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_shape_aspect is mantatory and can not be set to None') + if not check_type(value,shape_aspect): + self._relating_shape_aspect = shape_aspect(value) + else: + self._relating_shape_aspect = value + return property(**locals()) + + @apply + def related_shape_aspect(): + def fget( self ): + return self._related_shape_aspect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_shape_aspect is mantatory and can not be set to None') + if not check_type(value,shape_aspect): + self._related_shape_aspect = shape_aspect(value) + else: + self._related_shape_aspect = value + return property(**locals()) + + @apply + def id(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument id is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY shape_aspect_transition # +#################### +class shape_aspect_transition(shape_aspect_relationship): + '''Entity shape_aspect_transition definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ): + shape_aspect_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (self.self.name == ['g0','g1','g2']) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY organization_assignment # +#################### +class organization_assignment(BaseEntityClass): + '''Entity organization_assignment definition. + + :param assigned_organization + :type assigned_organization:organization + + :param role + :type role:organization_role + ''' + def __init__( self , assigned_organization,role, ): + self.assigned_organization = assigned_organization + self.role = role + + @apply + def assigned_organization(): + def fget( self ): + return self._assigned_organization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_organization is mantatory and can not be set to None') + if not check_type(value,organization): + self._assigned_organization = organization(value) + else: + self._assigned_organization = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,organization_role): + self._role = organization_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY applied_organization_assignment # +#################### +class applied_organization_assignment(organization_assignment): + '''Entity applied_organization_assignment definition. + + :param items + :type items:SET(1,None,'organization_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_organization , inherited1__role , items, ): + organization_assignment.__init__(self , inherited0__assigned_organization , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'organization_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (self.self.role.self.name == 'organization in contract')) or item_correlation(self.self.items,['CONTRACT'])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not (self.self.role.self.name == 'signing for contract')) or item_correlation(self.self.items,['APPLIED_ORGANIZATION_ASSIGNMENT'])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not (self.self.role.self.name == 'validity context')) or item_correlation(self.self.items,['ACTION_PROPERTY','RESOURCE_PROPERTY','PROPERTY_DEFINITION'])) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (self.self.role.self.name == 'alias scope')) or item_correlation(self.self.items,['APPLIED_IDENTIFICATION_ASSIGNMENT'])) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY measure_with_unit # +#################### +class measure_with_unit(BaseEntityClass): + '''Entity measure_with_unit definition. + + :param value_component + :type value_component:measure_value + + :param unit_component + :type unit_component:unit + ''' + def __init__( self , value_component,unit_component, ): + self.value_component = value_component + self.unit_component = unit_component + + @apply + def value_component(): + def fget( self ): + return self._value_component + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument value_component is mantatory and can not be set to None') + if not check_type(value,measure_value): + self._value_component = measure_value(value) + else: + self._value_component = value + return property(**locals()) + + @apply + def unit_component(): + def fget( self ): + return self._unit_component + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unit_component is mantatory and can not be set to None') + if not check_type(value,unit): + self._unit_component = unit(value) + else: + self._unit_component = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = valid_units(self) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY area_measure_with_unit # +#################### +class area_measure_with_unit(measure_with_unit): + '''Entity area_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.AREA_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY colour # +#################### +class colour(BaseEntityClass): + '''Entity colour definition. + ''' + # This class does not define any attribute. + pass + +#################### + # ENTITY concept_feature_operator # +#################### +class concept_feature_operator(BaseEntityClass): + '''Entity concept_feature_operator definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY default_tolerance_table # +#################### +class default_tolerance_table(representation): + '''Entity default_tolerance_table definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (((SIZEOF(None) == 0) and (SIZEOF(None) == 0)) and (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.REPRESENTATION_RELATIONSHIP.REP_2')) == 0)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY property_definition # +#################### +class property_definition(BaseEntityClass): + '''Entity property_definition definition. + + :param name + :type name:label + + :param description + :type description:text + + :param definition + :type definition:characterized_definition + + :param id + :type id:identifier + ''' + def __init__( self , name,description,definition, ): + self.name = name + self.description = description + self.definition = definition + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definition is mantatory and can not be set to None') + if not check_type(value,characterized_definition): + self._definition = characterized_definition(value) + else: + self._definition = value + return property(**locals()) + + @apply + def id(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument id is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_definition_shape # +#################### +class product_definition_shape(property_definition): + '''Entity product_definition_shape definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__definition , ): + property_definition.__init__(self , inherited0__name , inherited1__description , inherited2__definition , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.CHARACTERIZED_PRODUCT_DEFINITION','AUTOMOTIVE_DESIGN.CHARACTERIZED_OBJECT'] * TYPEOF(self.self.property_definition.self.definition)) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY featured_shape # +#################### +class featured_shape(product_definition_shape): + '''Entity featured_shape definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__definition , ): + product_definition_shape.__init__(self , inherited0__name , inherited1__description , inherited2__definition , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'PRODUCT_DEFINITION') == TYPEOF(self.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_RELATIONSHIP.RELATED_PROPERTY_DEFINITION')) == 1) and (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) >= 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY founded_kinematic_path # +#################### +class founded_kinematic_path(representation): + '''Entity founded_kinematic_path definition. + + :param representation_items + :type representation_items:SET(1,None,'kinematic_path', scope = schema_scope) + + :param representation_context_of_items + :type representation_context_of_items:geometric_representation_context + + :param paths + :type paths:SET(1,None,'kinematic_path', scope = schema_scope) + + :param founding + :type founding:geometric_representation_context + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , representation_items,representation_context_of_items, ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + self.representation_items = representation_items + self.representation_context_of_items = representation_context_of_items + + @apply + def representation_items(): + def fget( self ): + return self._representation_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'kinematic_path', scope = schema_scope)): + self._representation_items = SET(value) + else: + self._representation_items = value + return property(**locals()) + + @apply + def representation_context_of_items(): + def fget( self ): + return self._representation_context_of_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_context_of_items is mantatory and can not be set to None') + if not check_type(value,geometric_representation_context): + self._representation_context_of_items = geometric_representation_context(value) + else: + self._representation_context_of_items = value + return property(**locals()) + + @apply + def paths(): + def fget( self ): + attribute_eval = self.self.representation.self.items + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument paths is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def founding(): + def fget( self ): + attribute_eval = self.self.representation.self.context_of_items + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument founding is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY item_defined_transformation # +#################### +class item_defined_transformation(BaseEntityClass): + '''Entity item_defined_transformation definition. + + :param name + :type name:label + + :param description + :type description:text + + :param transform_item_1 + :type transform_item_1:representation_item + + :param transform_item_2 + :type transform_item_2:representation_item + ''' + def __init__( self , name,description,transform_item_1,transform_item_2, ): + self.name = name + self.description = description + self.transform_item_1 = transform_item_1 + self.transform_item_2 = transform_item_2 + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def transform_item_1(): + def fget( self ): + return self._transform_item_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transform_item_1 is mantatory and can not be set to None') + if not check_type(value,representation_item): + self._transform_item_1 = representation_item(value) + else: + self._transform_item_1 = value + return property(**locals()) + + @apply + def transform_item_2(): + def fget( self ): + return self._transform_item_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transform_item_2 is mantatory and can not be set to None') + if not check_type(value,representation_item): + self._transform_item_2 = representation_item(value) + else: + self._transform_item_2 = value + return property(**locals()) + +#################### + # ENTITY kinematic_pair # +#################### +class kinematic_pair(item_defined_transformation): + '''Entity kinematic_pair definition. + + :param joint + :type joint:kinematic_joint + + :param pair_placement_in_first_link_context + :type pair_placement_in_first_link_context:rigid_placement + + :param pair_placement_in_second_link_context + :type pair_placement_in_second_link_context:rigid_placement + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , joint, ): + item_defined_transformation.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , ) + self.joint = joint + + @apply + def joint(): + def fget( self ): + return self._joint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument joint is mantatory and can not be set to None') + if not check_type(value,kinematic_joint): + self._joint = kinematic_joint(value) + else: + self._joint = value + return property(**locals()) + + @apply + def pair_placement_in_first_link_context(): + def fget( self ): + attribute_eval = self.self.item_defined_transformation.self.transform_item_1 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument pair_placement_in_first_link_context is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def pair_placement_in_second_link_context(): + def fget( self ): + attribute_eval = self.self.item_defined_transformation.self.transform_item_2 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument pair_placement_in_second_link_context is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = coordinated_pair_link_representation(self.joint.self.first_link,self.pair_placement_in_first_link_context) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = coordinated_pair_link_representation(self.joint.self.second_link,self.pair_placement_in_second_link_context) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY gear_pair # +#################### +class gear_pair(kinematic_pair): + '''Entity gear_pair definition. + + :param radius_first_link + :type radius_first_link:length_measure + + :param radius_second_link + :type radius_second_link:length_measure + + :param bevel + :type bevel:plane_angle_measure + + :param helical_angle + :type helical_angle:plane_angle_measure + + :param gear_ratio + :type gear_ratio:REAL + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , radius_first_link,radius_second_link,bevel,helical_angle,gear_ratio, ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + self.radius_first_link = radius_first_link + self.radius_second_link = radius_second_link + self.bevel = bevel + self.helical_angle = helical_angle + self.gear_ratio = gear_ratio + + @apply + def radius_first_link(): + def fget( self ): + return self._radius_first_link + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius_first_link is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._radius_first_link = length_measure(value) + else: + self._radius_first_link = value + return property(**locals()) + + @apply + def radius_second_link(): + def fget( self ): + return self._radius_second_link + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius_second_link is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._radius_second_link = length_measure(value) + else: + self._radius_second_link = value + return property(**locals()) + + @apply + def bevel(): + def fget( self ): + return self._bevel + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bevel is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._bevel = plane_angle_measure(value) + else: + self._bevel = value + return property(**locals()) + + @apply + def helical_angle(): + def fget( self ): + return self._helical_angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument helical_angle is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._helical_angle = plane_angle_measure(value) + else: + self._helical_angle = value + return property(**locals()) + + @apply + def gear_ratio(): + def fget( self ): + return self._gear_ratio + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument gear_ratio is mantatory and can not be set to None') + if not check_type(value,REAL): + self._gear_ratio = REAL(value) + else: + self._gear_ratio = value + return property(**locals()) + +#################### + # ENTITY point_on_planar_curve_pair_range # +#################### +class point_on_planar_curve_pair_range(simple_pair_range): + '''Entity point_on_planar_curve_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:point_on_planar_curve_pair + + :param range_on_pair_curve + :type range_on_pair_curve:trimmed_curve + + :param lower_limit_yaw + :type lower_limit_yaw:rotational_range_measure + + :param upper_limit_yaw + :type upper_limit_yaw:rotational_range_measure + + :param lower_limit_pitch + :type lower_limit_pitch:rotational_range_measure + + :param upper_limit_pitch + :type upper_limit_pitch:rotational_range_measure + + :param lower_limit_roll + :type lower_limit_roll:rotational_range_measure + + :param upper_limit_roll + :type upper_limit_roll:rotational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,range_on_pair_curve,lower_limit_yaw,upper_limit_yaw,lower_limit_pitch,upper_limit_pitch,lower_limit_roll,upper_limit_roll, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.range_on_pair_curve = range_on_pair_curve + self.lower_limit_yaw = lower_limit_yaw + self.upper_limit_yaw = upper_limit_yaw + self.lower_limit_pitch = lower_limit_pitch + self.upper_limit_pitch = upper_limit_pitch + self.lower_limit_roll = lower_limit_roll + self.upper_limit_roll = upper_limit_roll + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,point_on_planar_curve_pair): + self._simple_pair_range_applies_to_pair = point_on_planar_curve_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def range_on_pair_curve(): + def fget( self ): + return self._range_on_pair_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument range_on_pair_curve is mantatory and can not be set to None') + if not check_type(value,trimmed_curve): + self._range_on_pair_curve = trimmed_curve(value) + else: + self._range_on_pair_curve = value + return property(**locals()) + + @apply + def lower_limit_yaw(): + def fget( self ): + return self._lower_limit_yaw + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_yaw is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_yaw = rotational_range_measure(value) + else: + self._lower_limit_yaw = value + return property(**locals()) + + @apply + def upper_limit_yaw(): + def fget( self ): + return self._upper_limit_yaw + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_yaw is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_yaw = rotational_range_measure(value) + else: + self._upper_limit_yaw = value + return property(**locals()) + + @apply + def lower_limit_pitch(): + def fget( self ): + return self._lower_limit_pitch + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_pitch is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_pitch = rotational_range_measure(value) + else: + self._lower_limit_pitch = value + return property(**locals()) + + @apply + def upper_limit_pitch(): + def fget( self ): + return self._upper_limit_pitch + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_pitch is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_pitch = rotational_range_measure(value) + else: + self._upper_limit_pitch = value + return property(**locals()) + + @apply + def lower_limit_roll(): + def fget( self ): + return self._lower_limit_roll + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_roll is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_roll = rotational_range_measure(value) + else: + self._lower_limit_roll = value + return property(**locals()) + + @apply + def upper_limit_roll(): + def fget( self ): + return self._upper_limit_roll + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_roll is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_roll = rotational_range_measure(value) + else: + self._upper_limit_roll = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.simple_pair_range.self.applies_to_pair.self.point_on_planar_curve_pair.self.pair_curve == self.range_on_pair_curve.self.basis_curve) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_yaw)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_yaw))) XOR (self.lower_limit_yaw < self.upper_limit_yaw)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_pitch)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_pitch))) XOR (self.lower_limit_pitch < self.upper_limit_pitch)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_roll)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_roll))) XOR (self.lower_limit_roll < self.upper_limit_roll)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY taper # +#################### +class taper(shape_aspect): + '''Entity taper definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.description == ['angle taper','diameter taper','directed taper']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'angle taper') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'diameter taper') or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((self.self.description != 'directed taper') or (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((self.self.description != 'directed taper') or ((SIZEOF(None) == 1) and (SIZEOF(None) == 1))) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + +#################### + # ENTITY barring_hole # +#################### +class barring_hole(feature_definition): + '''Entity barring_hole definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((SIZEOF(None) == 1) and (SIZEOF(None) == 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY fill_area_style_tile_symbol_with_style # +#################### +class fill_area_style_tile_symbol_with_style(geometric_representation_item): + '''Entity fill_area_style_tile_symbol_with_style definition. + + :param symbol + :type symbol:annotation_symbol_occurrence + ''' + def __init__( self , inherited0__name , symbol, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.symbol = symbol + + @apply + def symbol(): + def fget( self ): + return self._symbol + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument symbol is mantatory and can not be set to None') + if not check_type(value,annotation_symbol_occurrence): + self._symbol = annotation_symbol_occurrence(value) + else: + self._symbol = value + return property(**locals()) + +#################### + # ENTITY draughting_callout # +#################### +class draughting_callout(geometric_representation_item): + '''Entity draughting_callout definition. + + :param contents + :type contents:SET(1,None,'draughting_callout_element', scope = schema_scope) + ''' + def __init__( self , inherited0__name , contents, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.contents = contents + + @apply + def contents(): + def fget( self ): + return self._contents + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument contents is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'draughting_callout_element', scope = schema_scope)): + self._contents = SET(value) + else: + self._contents = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((((SIZEOF(None) == 0) or (('AUTOMOTIVE_DESIGN.LEADER_DIRECTED_CALLOUT' == TYPEOF(self)) and (SIZEOF(None) == 0))) or (('AUTOMOTIVE_DESIGN.PROJECTION_DIRECTED_CALLOUT' == TYPEOF(self)) and (SIZEOF(None) == 0))) or ('AUTOMOTIVE_DESIGN.DIMENSION_CURVE_DIRECTED_CALLOUT' == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY leader_directed_callout # +#################### +class leader_directed_callout(draughting_callout): + '''Entity leader_directed_callout definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) >= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(self.self.draughting_callout.self.contents) >= 2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY leader_directed_dimension # +#################### +class leader_directed_dimension(leader_directed_callout): + '''Entity leader_directed_dimension definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + leader_directed_callout.__init__(self , inherited0__name , inherited1__contents , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY presentation_representation # +#################### +class presentation_representation(representation): + '''Entity presentation_representation definition. + + :param representation_context_of_items + :type representation_context_of_items:geometric_representation_context + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , representation_context_of_items, ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + self.representation_context_of_items = representation_context_of_items + + @apply + def representation_context_of_items(): + def fget( self ): + return self._representation_context_of_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_context_of_items is mantatory and can not be set to None') + if not check_type(value,geometric_representation_context): + self._representation_context_of_items = geometric_representation_context(value) + else: + self._representation_context_of_items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.representation.self.context_of_items.self.geometric_representation_context.self.coordinate_space_dimension == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((('AUTOMOTIVE_DESIGN.PRESENTATION_AREA' == TYPEOF(self)) or (SIZEOF(None) > 0)) or (SIZEOF(None) > 0)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY presentation_area # +#################### +class presentation_area(presentation_representation): + '''Entity presentation_area definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , inherited3__representation_context_of_items , ): + presentation_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , inherited3__representation_context_of_items , ) + def wr1(self): + eval_wr1_wr = ((SIZEOF(None) > 0) or (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.PRESENTATION_SIZE.UNIT')) == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY mechanical_design_geometric_presentation_area # +#################### +class mechanical_design_geometric_presentation_area(presentation_area): + '''Entity mechanical_design_geometric_presentation_area definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , inherited3__representation_context_of_items , ): + presentation_area.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , inherited3__representation_context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((SIZEOF(None) == 0) and (SIZEOF(None) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (((SIZEOF(None) == 1) and (SIZEOF(None) == 0)) or ((SIZEOF(None) == 1) and (SIZEOF(None) == 1))) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY name_attribute # +#################### +class name_attribute(BaseEntityClass): + '''Entity name_attribute definition. + + :param attribute_value + :type attribute_value:label + + :param named_item + :type named_item:name_attribute_select + ''' + def __init__( self , attribute_value,named_item, ): + self.attribute_value = attribute_value + self.named_item = named_item + + @apply + def attribute_value(): + def fget( self ): + return self._attribute_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument attribute_value is mantatory and can not be set to None') + if not check_type(value,label): + self._attribute_value = label(value) + else: + self._attribute_value = value + return property(**locals()) + + @apply + def named_item(): + def fget( self ): + return self._named_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument named_item is mantatory and can not be set to None') + if not check_type(value,name_attribute_select): + self._named_item = name_attribute_select(value) + else: + self._named_item = value + return property(**locals()) + +#################### + # ENTITY planar_pair_range # +#################### +class planar_pair_range(simple_pair_range): + '''Entity planar_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:planar_pair + + :param lower_limit_actual_rotation + :type lower_limit_actual_rotation:rotational_range_measure + + :param upper_limit_actual_rotation + :type upper_limit_actual_rotation:rotational_range_measure + + :param lower_limit_actual_translation_x + :type lower_limit_actual_translation_x:translational_range_measure + + :param upper_limit_actual_translation_x + :type upper_limit_actual_translation_x:translational_range_measure + + :param lower_limit_actual_translation_y + :type lower_limit_actual_translation_y:translational_range_measure + + :param upper_limit_actual_translation_y + :type upper_limit_actual_translation_y:translational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,lower_limit_actual_rotation,upper_limit_actual_rotation,lower_limit_actual_translation_x,upper_limit_actual_translation_x,lower_limit_actual_translation_y,upper_limit_actual_translation_y, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.lower_limit_actual_rotation = lower_limit_actual_rotation + self.upper_limit_actual_rotation = upper_limit_actual_rotation + self.lower_limit_actual_translation_x = lower_limit_actual_translation_x + self.upper_limit_actual_translation_x = upper_limit_actual_translation_x + self.lower_limit_actual_translation_y = lower_limit_actual_translation_y + self.upper_limit_actual_translation_y = upper_limit_actual_translation_y + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,planar_pair): + self._simple_pair_range_applies_to_pair = planar_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def lower_limit_actual_rotation(): + def fget( self ): + return self._lower_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_actual_rotation = rotational_range_measure(value) + else: + self._lower_limit_actual_rotation = value + return property(**locals()) + + @apply + def upper_limit_actual_rotation(): + def fget( self ): + return self._upper_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_actual_rotation = rotational_range_measure(value) + else: + self._upper_limit_actual_rotation = value + return property(**locals()) + + @apply + def lower_limit_actual_translation_x(): + def fget( self ): + return self._lower_limit_actual_translation_x + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_translation_x is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._lower_limit_actual_translation_x = translational_range_measure(value) + else: + self._lower_limit_actual_translation_x = value + return property(**locals()) + + @apply + def upper_limit_actual_translation_x(): + def fget( self ): + return self._upper_limit_actual_translation_x + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_translation_x is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._upper_limit_actual_translation_x = translational_range_measure(value) + else: + self._upper_limit_actual_translation_x = value + return property(**locals()) + + @apply + def lower_limit_actual_translation_y(): + def fget( self ): + return self._lower_limit_actual_translation_y + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_translation_y is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._lower_limit_actual_translation_y = translational_range_measure(value) + else: + self._lower_limit_actual_translation_y = value + return property(**locals()) + + @apply + def upper_limit_actual_translation_y(): + def fget( self ): + return self._upper_limit_actual_translation_y + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_translation_y is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._upper_limit_actual_translation_y = translational_range_measure(value) + else: + self._upper_limit_actual_translation_y = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_rotation)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_rotation))) XOR (self.lower_limit_actual_rotation < self.upper_limit_actual_rotation)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_translation_x)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_translation_x))) XOR (self.lower_limit_actual_translation_x < self.upper_limit_actual_translation_x)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_translation_y)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_translation_y))) XOR (self.lower_limit_actual_translation_y < self.upper_limit_actual_translation_y)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY drawing_revision_sequence # +#################### +class drawing_revision_sequence(BaseEntityClass): + '''Entity drawing_revision_sequence definition. + + :param predecessor + :type predecessor:drawing_revision + + :param successor + :type successor:drawing_revision + ''' + def __init__( self , predecessor,successor, ): + self.predecessor = predecessor + self.successor = successor + + @apply + def predecessor(): + def fget( self ): + return self._predecessor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predecessor is mantatory and can not be set to None') + if not check_type(value,drawing_revision): + self._predecessor = drawing_revision(value) + else: + self._predecessor = value + return property(**locals()) + + @apply + def successor(): + def fget( self ): + return self._successor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument successor is mantatory and can not be set to None') + if not check_type(value,drawing_revision): + self._successor = drawing_revision(value) + else: + self._successor = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.predecessor != self.successor) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY effectivity # +#################### +class effectivity(BaseEntityClass): + '''Entity effectivity definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , id, ): + self.id = id + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY serial_numbered_effectivity # +#################### +class serial_numbered_effectivity(effectivity): + '''Entity serial_numbered_effectivity definition. + + :param effectivity_start_id + :type effectivity_start_id:identifier + + :param effectivity_end_id + :type effectivity_end_id:identifier + ''' + def __init__( self , inherited0__id , effectivity_start_id,effectivity_end_id, ): + effectivity.__init__(self , inherited0__id , ) + self.effectivity_start_id = effectivity_start_id + self.effectivity_end_id = effectivity_end_id + + @apply + def effectivity_start_id(): + def fget( self ): + return self._effectivity_start_id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument effectivity_start_id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._effectivity_start_id = identifier(value) + else: + self._effectivity_start_id = value + return property(**locals()) + + @apply + def effectivity_end_id(): + def fget( self ): + return self._effectivity_end_id + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,identifier): + self._effectivity_end_id = identifier(value) + else: + self._effectivity_end_id = value + else: + self._effectivity_end_id = value + return property(**locals()) + +#################### + # ENTITY product_concept_feature_association # +#################### +class product_concept_feature_association(BaseEntityClass): + '''Entity product_concept_feature_association definition. + + :param name + :type name:label + + :param description + :type description:text + + :param concept + :type concept:product_concept + + :param feature + :type feature:product_concept_feature + ''' + def __init__( self , name,description,concept,feature, ): + self.name = name + self.description = description + self.concept = concept + self.feature = feature + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def concept(): + def fget( self ): + return self._concept + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument concept is mantatory and can not be set to None') + if not check_type(value,product_concept): + self._concept = product_concept(value) + else: + self._concept = value + return property(**locals()) + + @apply + def feature(): + def fget( self ): + return self._feature + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument feature is mantatory and can not be set to None') + if not check_type(value,product_concept_feature): + self._feature = product_concept_feature(value) + else: + self._feature = value + return property(**locals()) + +#################### + # ENTITY date_and_time_assignment # +#################### +class date_and_time_assignment(BaseEntityClass): + '''Entity date_and_time_assignment definition. + + :param assigned_date_and_time + :type assigned_date_and_time:date_and_time + + :param role + :type role:date_time_role + ''' + def __init__( self , assigned_date_and_time,role, ): + self.assigned_date_and_time = assigned_date_and_time + self.role = role + + @apply + def assigned_date_and_time(): + def fget( self ): + return self._assigned_date_and_time + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_date_and_time is mantatory and can not be set to None') + if not check_type(value,date_and_time): + self._assigned_date_and_time = date_and_time(value) + else: + self._assigned_date_and_time = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,date_time_role): + self._role = date_time_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY applied_date_and_time_assignment # +#################### +class applied_date_and_time_assignment(date_and_time_assignment): + '''Entity applied_date_and_time_assignment definition. + + :param items + :type items:SET(1,None,'date_and_time_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_date_and_time , inherited1__role , items, ): + date_and_time_assignment.__init__(self , inherited0__assigned_date_and_time , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'date_and_time_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY multiple_arity_numeric_expression # +#################### +class multiple_arity_numeric_expression(numeric_expression,multiple_arity_generic_expression): + '''Entity multiple_arity_numeric_expression definition. + + :param multiple_arity_generic_expression_operands + :type multiple_arity_generic_expression_operands:LIST(2,None,'numeric_expression', scope = schema_scope) + ''' + def __init__( self , inherited0__operands , multiple_arity_generic_expression_operands, ): + numeric_expression.__init__(self , ) + multiple_arity_generic_expression.__init__(self , inherited0__operands , ) + self.multiple_arity_generic_expression_operands = multiple_arity_generic_expression_operands + + @apply + def multiple_arity_generic_expression_operands(): + def fget( self ): + return self._multiple_arity_generic_expression_operands + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument multiple_arity_generic_expression_operands is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'numeric_expression', scope = schema_scope)): + self._multiple_arity_generic_expression_operands = LIST(value) + else: + self._multiple_arity_generic_expression_operands = value + return property(**locals()) + +#################### + # ENTITY screw_pair # +#################### +class screw_pair(kinematic_pair): + '''Entity screw_pair definition. + + :param pitch + :type pitch:length_measure + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , pitch, ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + self.pitch = pitch + + @apply + def pitch(): + def fget( self ): + return self._pitch + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pitch is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._pitch = length_measure(value) + else: + self._pitch = value + return property(**locals()) + +#################### + # ENTITY surface_pair # +#################### +class surface_pair(kinematic_pair): + '''Entity surface_pair definition. + + :param surface_1 + :type surface_1:surface + + :param surface_2 + :type surface_2:surface + + :param orientation + :type orientation:BOOLEAN + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , surface_1,surface_2,orientation, ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + self.surface_1 = surface_1 + self.surface_2 = surface_2 + self.orientation = orientation + + @apply + def surface_1(): + def fget( self ): + return self._surface_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument surface_1 is mantatory and can not be set to None') + if not check_type(value,surface): + self._surface_1 = surface(value) + else: + self._surface_1 = value + return property(**locals()) + + @apply + def surface_2(): + def fget( self ): + return self._surface_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument surface_2 is mantatory and can not be set to None') + if not check_type(value,surface): + self._surface_2 = surface(value) + else: + self._surface_2 = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = frame_associated_to_background(self.self.kinematic_pair.self.pair_placement_in_first_link_context,self.surface_1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = frame_associated_to_background(self.self.kinematic_pair.self.pair_placement_in_second_link_context,self.surface_2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY sliding_surface_pair # +#################### +class sliding_surface_pair(surface_pair): + '''Entity sliding_surface_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__surface_1 , inherited6__surface_2 , inherited7__orientation , ): + surface_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__surface_1 , inherited6__surface_2 , inherited7__orientation , ) + +#################### + # ENTITY mapped_item # +#################### +class mapped_item(representation_item): + '''Entity mapped_item definition. + + :param mapping_source + :type mapping_source:representation_map + + :param mapping_target + :type mapping_target:representation_item + ''' + def __init__( self , inherited0__name , mapping_source,mapping_target, ): + representation_item.__init__(self , inherited0__name , ) + self.mapping_source = mapping_source + self.mapping_target = mapping_target + + @apply + def mapping_source(): + def fget( self ): + return self._mapping_source + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapping_source is mantatory and can not be set to None') + if not check_type(value,representation_map): + self._mapping_source = representation_map(value) + else: + self._mapping_source = value + return property(**locals()) + + @apply + def mapping_target(): + def fget( self ): + return self._mapping_target + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapping_target is mantatory and can not be set to None') + if not check_type(value,representation_item): + self._mapping_target = representation_item(value) + else: + self._mapping_target = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = acyclic_mapped_representation(using_representations(self),[self]) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY annotation_text_character # +#################### +class annotation_text_character(mapped_item): + '''Entity annotation_text_character definition. + + :param alignment + :type alignment:text_alignment + + :param mapped_item_mapping_target + :type mapped_item_mapping_target:axis2_placement + ''' + def __init__( self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , alignment,mapped_item_mapping_target, ): + mapped_item.__init__(self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , ) + self.alignment = alignment + self.mapped_item_mapping_target = mapped_item_mapping_target + + @apply + def alignment(): + def fget( self ): + return self._alignment + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument alignment is mantatory and can not be set to None') + if not check_type(value,text_alignment): + self._alignment = text_alignment(value) + else: + self._alignment = value + return property(**locals()) + + @apply + def mapped_item_mapping_target(): + def fget( self ): + return self._mapped_item_mapping_target + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapped_item_mapping_target is mantatory and can not be set to None') + if not check_type(value,axis2_placement): + self._mapped_item_mapping_target = axis2_placement(value) + else: + self._mapped_item_mapping_target = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.CHARACTER_GLYPH_SYMBOL' == TYPEOF(self.self.mapped_item.self.mapping_source.self.mapped_representation)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('AUTOMOTIVE_DESIGN.GEOMETRIC_REPRESENTATION_ITEM' == TYPEOF(self)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY surface # +#################### +class surface(geometric_representation_item): + '''Entity surface definition. + ''' + def __init__( self , inherited0__name , ): + geometric_representation_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY oriented_surface # +#################### +class oriented_surface(surface): + '''Entity oriented_surface definition. + + :param orientation + :type orientation:BOOLEAN + ''' + def __init__( self , inherited0__name , orientation, ): + surface.__init__(self , inherited0__name , ) + self.orientation = orientation + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + +#################### + # ENTITY offset_surface # +#################### +class offset_surface(surface): + '''Entity offset_surface definition. + + :param basis_surface + :type basis_surface:surface + + :param distance + :type distance:length_measure + + :param self_intersect + :type self_intersect:LOGICAL + ''' + def __init__( self , inherited0__name , basis_surface,distance,self_intersect, ): + surface.__init__(self , inherited0__name , ) + self.basis_surface = basis_surface + self.distance = distance + self.self_intersect = self_intersect + + @apply + def basis_surface(): + def fget( self ): + return self._basis_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._basis_surface = surface(value) + else: + self._basis_surface = value + return property(**locals()) + + @apply + def distance(): + def fget( self ): + return self._distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distance is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._distance = length_measure(value) + else: + self._distance = value + return property(**locals()) + + @apply + def self_intersect(): + def fget( self ): + return self._self_intersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument self_intersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._self_intersect = LOGICAL(value) + else: + self._self_intersect = value + return property(**locals()) + +#################### + # ENTITY placement # +#################### +class placement(geometric_representation_item): + '''Entity placement definition. + + :param location + :type location:cartesian_point + ''' + def __init__( self , inherited0__name , location, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.location = location + + @apply + def location(): + def fget( self ): + return self._location + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument location is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._location = cartesian_point(value) + else: + self._location = value + return property(**locals()) + +#################### + # ENTITY axis2_placement_2d # +#################### +class axis2_placement_2d(placement): + '''Entity axis2_placement_2d definition. + + :param ref_direction + :type ref_direction:direction + + :param p + :type p:LIST(2,2,'direction', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__location , ref_direction, ): + placement.__init__(self , inherited0__name , inherited1__location , ) + self.ref_direction = ref_direction + + @apply + def ref_direction(): + def fget( self ): + return self._ref_direction + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,direction): + self._ref_direction = direction(value) + else: + self._ref_direction = value + else: + self._ref_direction = value + return property(**locals()) + + @apply + def p(): + def fget( self ): + attribute_eval = build_2axes(self.ref_direction) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument p is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.geometric_representation_item.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY composite_shape_aspect # +#################### +class composite_shape_aspect(shape_aspect): + '''Entity composite_shape_aspect definition. + + :param component_relationships + :type component_relationships:SET(2,None,'shape_aspect_relationship', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + + @apply + def component_relationships(): + def fget( self ): + return self._component_relationships + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument component_relationships is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY general_property # +#################### +class general_property(BaseEntityClass): + '''Entity general_property definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , id,name,description, ): + self.id = id + self.name = name + self.description = description + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY general_material_property # +#################### +class general_material_property(general_property): + '''Entity general_material_property definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , ): + general_property.__init__(self , inherited0__id , inherited1__name , inherited2__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_category # +#################### +class product_category(BaseEntityClass): + '''Entity product_category definition. + + :param name + :type name:label + + :param description + :type description:text + + :param id + :type id:identifier + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def id(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument id is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_related_product_category # +#################### +class product_related_product_category(product_category): + '''Entity product_related_product_category definition. + + :param products + :type products:SET(1,None,'product', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , products, ): + product_category.__init__(self , inherited0__name , inherited1__description , ) + self.products = products + + @apply + def products(): + def fget( self ): + return self._products + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument products is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'product', scope = schema_scope)): + self._products = SET(value) + else: + self._products = value + return property(**locals()) + +#################### + # ENTITY shape_representation_with_parameters # +#################### +class shape_representation_with_parameters(shape_representation): + '''Entity shape_representation_with_parameters definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == SIZEOF(self.self.items)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY curve # +#################### +class curve(geometric_representation_item): + '''Entity curve definition. + ''' + def __init__( self , inherited0__name , ): + geometric_representation_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY conic # +#################### +class conic(curve): + '''Entity conic definition. + + :param position + :type position:axis2_placement + ''' + def __init__( self , inherited0__name , position, ): + curve.__init__(self , inherited0__name , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,axis2_placement): + self._position = axis2_placement(value) + else: + self._position = value + return property(**locals()) + +#################### + # ENTITY hyperbola # +#################### +class hyperbola(conic): + '''Entity hyperbola definition. + + :param semi_axis + :type semi_axis:positive_length_measure + + :param semi_imag_axis + :type semi_imag_axis:positive_length_measure + ''' + def __init__( self , inherited0__name , inherited1__position , semi_axis,semi_imag_axis, ): + conic.__init__(self , inherited0__name , inherited1__position , ) + self.semi_axis = semi_axis + self.semi_imag_axis = semi_imag_axis + + @apply + def semi_axis(): + def fget( self ): + return self._semi_axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semi_axis is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._semi_axis = positive_length_measure(value) + else: + self._semi_axis = value + return property(**locals()) + + @apply + def semi_imag_axis(): + def fget( self ): + return self._semi_imag_axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semi_imag_axis is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._semi_imag_axis = positive_length_measure(value) + else: + self._semi_imag_axis = value + return property(**locals()) + +#################### + # ENTITY path_shape_representation # +#################### +class path_shape_representation(shape_representation): + '''Entity path_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.items) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY shape_aspect_deriving_relationship # +#################### +class shape_aspect_deriving_relationship(shape_aspect_relationship): + '''Entity shape_aspect_deriving_relationship definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ): + shape_aspect_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.DERIVED_SHAPE_ASPECT' == TYPEOF(self.self.shape_aspect_relationship.self.relating_shape_aspect)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY tolerance_zone_form # +#################### +class tolerance_zone_form(BaseEntityClass): + '''Entity tolerance_zone_form definition. + + :param name + :type name:label + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY uncertainty_qualifier # +#################### +class uncertainty_qualifier(BaseEntityClass): + '''Entity uncertainty_qualifier definition. + + :param measure_name + :type measure_name:label + + :param description + :type description:text + ''' + def __init__( self , measure_name,description, ): + self.measure_name = measure_name + self.description = description + + @apply + def measure_name(): + def fget( self ): + return self._measure_name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument measure_name is mantatory and can not be set to None') + if not check_type(value,label): + self._measure_name = label(value) + else: + self._measure_name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY composite_text # +#################### +class composite_text(geometric_representation_item): + '''Entity composite_text definition. + + :param collected_text + :type collected_text:SET(2,None,'text_or_character', scope = schema_scope) + ''' + def __init__( self , inherited0__name , collected_text, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.collected_text = collected_text + + @apply + def collected_text(): + def fget( self ): + return self._collected_text + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument collected_text is mantatory and can not be set to None') + if not check_type(value,SET(2,None,'text_or_character', scope = schema_scope)): + self._collected_text = SET(value) + else: + self._collected_text = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = acyclic_composite_text(self,self.self.collected_text) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY composite_text_with_extent # +#################### +class composite_text_with_extent(composite_text): + '''Entity composite_text_with_extent definition. + + :param extent + :type extent:planar_extent + ''' + def __init__( self , inherited0__name , inherited1__collected_text , extent, ): + composite_text.__init__(self , inherited0__name , inherited1__collected_text , ) + self.extent = extent + + @apply + def extent(): + def fget( self ): + return self._extent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extent is mantatory and can not be set to None') + if not check_type(value,planar_extent): + self._extent = planar_extent(value) + else: + self._extent = value + return property(**locals()) + +#################### + # ENTITY address # +#################### +class address(BaseEntityClass): + '''Entity address definition. + + :param internal_location + :type internal_location:label + + :param street_number + :type street_number:label + + :param street + :type street:label + + :param postal_box + :type postal_box:label + + :param town + :type town:label + + :param region + :type region:label + + :param postal_code + :type postal_code:label + + :param country + :type country:label + + :param facsimile_number + :type facsimile_number:label + + :param telephone_number + :type telephone_number:label + + :param electronic_mail_address + :type electronic_mail_address:label + + :param telex_number + :type telex_number:label + + :param name + :type name:label + + :param url + :type url:identifier + ''' + def __init__( self , internal_location,street_number,street,postal_box,town,region,postal_code,country,facsimile_number,telephone_number,electronic_mail_address,telex_number, ): + self.internal_location = internal_location + self.street_number = street_number + self.street = street + self.postal_box = postal_box + self.town = town + self.region = region + self.postal_code = postal_code + self.country = country + self.facsimile_number = facsimile_number + self.telephone_number = telephone_number + self.electronic_mail_address = electronic_mail_address + self.telex_number = telex_number + + @apply + def internal_location(): + def fget( self ): + return self._internal_location + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._internal_location = label(value) + else: + self._internal_location = value + else: + self._internal_location = value + return property(**locals()) + + @apply + def street_number(): + def fget( self ): + return self._street_number + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._street_number = label(value) + else: + self._street_number = value + else: + self._street_number = value + return property(**locals()) + + @apply + def street(): + def fget( self ): + return self._street + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._street = label(value) + else: + self._street = value + else: + self._street = value + return property(**locals()) + + @apply + def postal_box(): + def fget( self ): + return self._postal_box + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._postal_box = label(value) + else: + self._postal_box = value + else: + self._postal_box = value + return property(**locals()) + + @apply + def town(): + def fget( self ): + return self._town + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._town = label(value) + else: + self._town = value + else: + self._town = value + return property(**locals()) + + @apply + def region(): + def fget( self ): + return self._region + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._region = label(value) + else: + self._region = value + else: + self._region = value + return property(**locals()) + + @apply + def postal_code(): + def fget( self ): + return self._postal_code + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._postal_code = label(value) + else: + self._postal_code = value + else: + self._postal_code = value + return property(**locals()) + + @apply + def country(): + def fget( self ): + return self._country + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._country = label(value) + else: + self._country = value + else: + self._country = value + return property(**locals()) + + @apply + def facsimile_number(): + def fget( self ): + return self._facsimile_number + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._facsimile_number = label(value) + else: + self._facsimile_number = value + else: + self._facsimile_number = value + return property(**locals()) + + @apply + def telephone_number(): + def fget( self ): + return self._telephone_number + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._telephone_number = label(value) + else: + self._telephone_number = value + else: + self._telephone_number = value + return property(**locals()) + + @apply + def electronic_mail_address(): + def fget( self ): + return self._electronic_mail_address + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._electronic_mail_address = label(value) + else: + self._electronic_mail_address = value + else: + self._electronic_mail_address = value + return property(**locals()) + + @apply + def telex_number(): + def fget( self ): + return self._telex_number + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._telex_number = label(value) + else: + self._telex_number = value + else: + self._telex_number = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def url(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument url is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (((((((((((EXISTS(self.internal_location) or EXISTS(self.street_number)) or EXISTS(self.street)) or EXISTS(self.postal_box)) or EXISTS(self.town)) or EXISTS(self.region)) or EXISTS(self.postal_code)) or EXISTS(self.country)) or EXISTS(self.facsimile_number)) or EXISTS(self.telephone_number)) or EXISTS(self.electronic_mail_address)) or EXISTS(self.telex_number)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY organizational_address # +#################### +class organizational_address(address): + '''Entity organizational_address definition. + + :param organizations + :type organizations:SET(1,None,'organization', scope = schema_scope) + + :param description + :type description:text + ''' + def __init__( self , inherited0__internal_location , inherited1__street_number , inherited2__street , inherited3__postal_box , inherited4__town , inherited5__region , inherited6__postal_code , inherited7__country , inherited8__facsimile_number , inherited9__telephone_number , inherited10__electronic_mail_address , inherited11__telex_number , organizations,description, ): + address.__init__(self , inherited0__internal_location , inherited1__street_number , inherited2__street , inherited3__postal_box , inherited4__town , inherited5__region , inherited6__postal_code , inherited7__country , inherited8__facsimile_number , inherited9__telephone_number , inherited10__electronic_mail_address , inherited11__telex_number , ) + self.organizations = organizations + self.description = description + + @apply + def organizations(): + def fget( self ): + return self._organizations + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument organizations is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'organization', scope = schema_scope)): + self._organizations = SET(value) + else: + self._organizations = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY bounded_surface # +#################### +class bounded_surface(surface): + '''Entity bounded_surface definition. + ''' + def __init__( self , inherited0__name , ): + surface.__init__(self , inherited0__name , ) + +#################### + # ENTITY b_spline_surface # +#################### +class b_spline_surface(bounded_surface): + '''Entity b_spline_surface definition. + + :param u_degree + :type u_degree:INTEGER + + :param v_degree + :type v_degree:INTEGER + + :param control_points_list + :type control_points_list:LIST(2,None,LIST(2,None,'cartesian_point', scope = schema_scope)) + + :param surface_form + :type surface_form:b_spline_surface_form + + :param u_closed + :type u_closed:LOGICAL + + :param v_closed + :type v_closed:LOGICAL + + :param self_intersect + :type self_intersect:LOGICAL + + :param u_upper + :type u_upper:INTEGER + + :param v_upper + :type v_upper:INTEGER + + :param control_points + :type control_points:ARRAY(0,u_upper,ARRAY(0,v_upper,'cartesian_point', scope = schema_scope)) + ''' + def __init__( self , inherited0__name , u_degree,v_degree,control_points_list,surface_form,u_closed,v_closed,self_intersect, ): + bounded_surface.__init__(self , inherited0__name , ) + self.u_degree = u_degree + self.v_degree = v_degree + self.control_points_list = control_points_list + self.surface_form = surface_form + self.u_closed = u_closed + self.v_closed = v_closed + self.self_intersect = self_intersect + + @apply + def u_degree(): + def fget( self ): + return self._u_degree + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u_degree is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._u_degree = INTEGER(value) + else: + self._u_degree = value + return property(**locals()) + + @apply + def v_degree(): + def fget( self ): + return self._v_degree + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v_degree is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._v_degree = INTEGER(value) + else: + self._v_degree = value + return property(**locals()) + + @apply + def control_points_list(): + def fget( self ): + return self._control_points_list + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument control_points_list is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,LIST(2,None,'cartesian_point', scope = schema_scope))): + self._control_points_list = LIST(value) + else: + self._control_points_list = value + return property(**locals()) + + @apply + def surface_form(): + def fget( self ): + return self._surface_form + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument surface_form is mantatory and can not be set to None') + if not check_type(value,b_spline_surface_form): + self._surface_form = b_spline_surface_form(value) + else: + self._surface_form = value + return property(**locals()) + + @apply + def u_closed(): + def fget( self ): + return self._u_closed + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u_closed is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._u_closed = LOGICAL(value) + else: + self._u_closed = value + return property(**locals()) + + @apply + def v_closed(): + def fget( self ): + return self._v_closed + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v_closed is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._v_closed = LOGICAL(value) + else: + self._v_closed = value + return property(**locals()) + + @apply + def self_intersect(): + def fget( self ): + return self._self_intersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument self_intersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._self_intersect = LOGICAL(value) + else: + self._self_intersect = value + return property(**locals()) + + @apply + def u_upper(): + def fget( self ): + attribute_eval = (SIZEOF(self.control_points_list) - 1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument u_upper is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def v_upper(): + def fget( self ): + attribute_eval = (SIZEOF(self.control_points_list[1]) - 1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument v_upper is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def control_points(): + def fget( self ): + attribute_eval = make_array_of_array(self.control_points_list,0,self.u_upper,0,self.v_upper) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument control_points is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (((('AUTOMOTIVE_DESIGN.UNIFORM_SURFACE' == TYPEOF(self)) or ('AUTOMOTIVE_DESIGN.QUASI_UNIFORM_SURFACE' == TYPEOF(self))) or ('AUTOMOTIVE_DESIGN.BEZIER_SURFACE' == TYPEOF(self))) or ('AUTOMOTIVE_DESIGN.B_SPLINE_SURFACE_WITH_KNOTS' == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY uniform_surface # +#################### +class uniform_surface(b_spline_surface): + '''Entity uniform_surface definition. + ''' + def __init__( self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , ): + b_spline_surface.__init__(self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , ) + +#################### + # ENTITY geometrically_bounded_surface_shape_representation # +#################### +class geometrically_bounded_surface_shape_representation(shape_representation): + '''Entity geometrically_bounded_surface_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) > 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY line_profile_tolerance # +#################### +class line_profile_tolerance(geometric_tolerance): + '''Entity line_profile_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + def wr1(self): + eval_wr1_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE') == TYPEOF(self))) or (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) <= 3)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY text_style # +#################### +class text_style(founded_item): + '''Entity text_style definition. + + :param name + :type name:label + + :param character_appearance + :type character_appearance:character_style_select + ''' + def __init__( self , name,character_appearance, ): + founded_item.__init__(self , ) + self.name = name + self.character_appearance = character_appearance + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def character_appearance(): + def fget( self ): + return self._character_appearance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument character_appearance is mantatory and can not be set to None') + if not check_type(value,character_style_select): + self._character_appearance = character_style_select(value) + else: + self._character_appearance = value + return property(**locals()) + +#################### + # ENTITY axis1_placement # +#################### +class axis1_placement(placement): + '''Entity axis1_placement definition. + + :param axis + :type axis:direction + + :param z + :type z:direction + ''' + def __init__( self , inherited0__name , inherited1__location , axis, ): + placement.__init__(self , inherited0__name , inherited1__location , ) + self.axis = axis + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,direction): + self._axis = direction(value) + else: + self._axis = value + else: + self._axis = value + return property(**locals()) + + @apply + def z(): + def fget( self ): + attribute_eval = NVL(normalise(self.axis),self.dummy_gri == direction([0,0,1])) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument z is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.geometric_representation_item.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY symbol_representation # +#################### +class symbol_representation(representation): + '''Entity symbol_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + +#################### + # ENTITY generic_character_glyph_symbol # +#################### +class generic_character_glyph_symbol(symbol_representation): + '''Entity generic_character_glyph_symbol definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + symbol_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + +#################### + # ENTITY string_expression # +#################### +class string_expression(expression): + '''Entity string_expression definition. + ''' + def __init__( self , ): + expression.__init__(self , ) + +#################### + # ENTITY binary_generic_expression # +#################### +class binary_generic_expression(generic_expression): + '''Entity binary_generic_expression definition. + + :param operands + :type operands:LIST(2,2,'generic_expression', scope = schema_scope) + ''' + def __init__( self , operands, ): + generic_expression.__init__(self , ) + self.operands = operands + + @apply + def operands(): + def fget( self ): + return self._operands + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operands is mantatory and can not be set to None') + if not check_type(value,LIST(2,2,'generic_expression', scope = schema_scope)): + self._operands = LIST(value) + else: + self._operands = value + return property(**locals()) + +#################### + # ENTITY index_expression # +#################### +class index_expression(string_expression,binary_generic_expression): + '''Entity index_expression definition. + + :param operand + :type operand:generic_expression + + :param index + :type index:generic_expression + ''' + def __init__( self , inherited0__operands , ): + string_expression.__init__(self , ) + binary_generic_expression.__init__(self , inherited0__operands , ) + + @apply + def operand(): + def fget( self ): + attribute_eval = self.self.binary_generic_expression.self.operands[1] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument operand is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def index(): + def fget( self ): + attribute_eval = self.self.binary_generic_expression.self.operands[2] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument index is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.operand)) and ('AUTOMOTIVE_DESIGN.NUMERIC_EXPRESSION' == TYPEOF(self.index))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = is_int_expr(self.index) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY identification_assignment # +#################### +class identification_assignment(BaseEntityClass): + '''Entity identification_assignment definition. + + :param assigned_id + :type assigned_id:identifier + + :param role + :type role:identification_role + ''' + def __init__( self , assigned_id,role, ): + self.assigned_id = assigned_id + self.role = role + + @apply + def assigned_id(): + def fget( self ): + return self._assigned_id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._assigned_id = identifier(value) + else: + self._assigned_id = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,identification_role): + self._role = identification_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY external_identification_assignment # +#################### +class external_identification_assignment(identification_assignment): + '''Entity external_identification_assignment definition. + + :param source + :type source:external_source + ''' + def __init__( self , inherited0__assigned_id , inherited1__role , source, ): + identification_assignment.__init__(self , inherited0__assigned_id , inherited1__role , ) + self.source = source + + @apply + def source(): + def fget( self ): + return self._source + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument source is mantatory and can not be set to None') + if not check_type(value,external_source): + self._source = external_source(value) + else: + self._source = value + return property(**locals()) + +#################### + # ENTITY applied_external_identification_assignment # +#################### +class applied_external_identification_assignment(external_identification_assignment): + '''Entity applied_external_identification_assignment definition. + + :param items + :type items:SET(1,None,'external_identification_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_id , inherited1__role , inherited2__source , items, ): + external_identification_assignment.__init__(self , inherited0__assigned_id , inherited1__role , inherited2__source , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'external_identification_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (self.self.role.self.name == 'alternative document id and location')) or item_correlation(self.self.items,['DOCUMENT_FILE'])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not (self.self.role.self.name == 'version')) or item_correlation(self.self.items,['EXTERNALLY_DEFINED_CLASS','EXTERNALLY_DEFINED_GENERAL_PROPERTY'])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY csg_shape_representation # +#################### +class csg_shape_representation(shape_representation): + '''Entity csg_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (self.self.context_of_items.self.geometric_representation_context.self.coordinate_space_dimension == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) > 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY defined_function # +#################### +class defined_function(BaseEntityClass): + '''Entity defined_function definition. + ''' + # This class does not define any attribute. + pass + +#################### + # ENTITY numeric_defined_function # +#################### +class numeric_defined_function(numeric_expression,defined_function): + '''Entity numeric_defined_function definition. + ''' + def __init__( self , ): + numeric_expression.__init__(self , ) + defined_function.__init__(self , ) + +#################### + # ENTITY integer_defined_function # +#################### +class integer_defined_function(numeric_defined_function): + '''Entity integer_defined_function definition. + ''' + def __init__( self , ): + numeric_defined_function.__init__(self , ) + +#################### + # ENTITY pre_defined_item # +#################### +class pre_defined_item(BaseEntityClass): + '''Entity pre_defined_item definition. + + :param name + :type name:label + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY pre_defined_symbol # +#################### +class pre_defined_symbol(pre_defined_item): + '''Entity pre_defined_symbol definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY pre_defined_dimension_symbol # +#################### +class pre_defined_dimension_symbol(pre_defined_symbol): + '''Entity pre_defined_dimension_symbol definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_symbol.__init__(self , inherited0__name , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['arc length','conical taper','counterbore','countersink','depth','diameter','plus minus','radius','slope','spherical diameter','spherical radius','square']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY bounded_curve # +#################### +class bounded_curve(curve): + '''Entity bounded_curve definition. + ''' + def __init__( self , inherited0__name , ): + curve.__init__(self , inherited0__name , ) + +#################### + # ENTITY b_spline_curve # +#################### +class b_spline_curve(bounded_curve): + '''Entity b_spline_curve definition. + + :param degree + :type degree:INTEGER + + :param control_points_list + :type control_points_list:LIST(2,None,'cartesian_point', scope = schema_scope) + + :param curve_form + :type curve_form:b_spline_curve_form + + :param closed_curve + :type closed_curve:LOGICAL + + :param self_intersect + :type self_intersect:LOGICAL + + :param upper_index_on_control_points + :type upper_index_on_control_points:INTEGER + + :param control_points + :type control_points:ARRAY(0,upper_index_on_control_points,'cartesian_point', scope = schema_scope) + ''' + def __init__( self , inherited0__name , degree,control_points_list,curve_form,closed_curve,self_intersect, ): + bounded_curve.__init__(self , inherited0__name , ) + self.degree = degree + self.control_points_list = control_points_list + self.curve_form = curve_form + self.closed_curve = closed_curve + self.self_intersect = self_intersect + + @apply + def degree(): + def fget( self ): + return self._degree + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument degree is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._degree = INTEGER(value) + else: + self._degree = value + return property(**locals()) + + @apply + def control_points_list(): + def fget( self ): + return self._control_points_list + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument control_points_list is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'cartesian_point', scope = schema_scope)): + self._control_points_list = LIST(value) + else: + self._control_points_list = value + return property(**locals()) + + @apply + def curve_form(): + def fget( self ): + return self._curve_form + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curve_form is mantatory and can not be set to None') + if not check_type(value,b_spline_curve_form): + self._curve_form = b_spline_curve_form(value) + else: + self._curve_form = value + return property(**locals()) + + @apply + def closed_curve(): + def fget( self ): + return self._closed_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument closed_curve is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._closed_curve = LOGICAL(value) + else: + self._closed_curve = value + return property(**locals()) + + @apply + def self_intersect(): + def fget( self ): + return self._self_intersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument self_intersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._self_intersect = LOGICAL(value) + else: + self._self_intersect = value + return property(**locals()) + + @apply + def upper_index_on_control_points(): + def fget( self ): + attribute_eval = (SIZEOF(self.control_points_list) - 1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument upper_index_on_control_points is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def control_points(): + def fget( self ): + attribute_eval = list_to_array(self.control_points_list,0,self.upper_index_on_control_points) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument control_points is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (((('AUTOMOTIVE_DESIGN.UNIFORM_CURVE' == TYPEOF(self)) or ('AUTOMOTIVE_DESIGN.QUASI_UNIFORM_CURVE' == TYPEOF(self))) or ('AUTOMOTIVE_DESIGN.BEZIER_CURVE' == TYPEOF(self))) or ('AUTOMOTIVE_DESIGN.B_SPLINE_CURVE_WITH_KNOTS' == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY rational_b_spline_curve # +#################### +class rational_b_spline_curve(b_spline_curve): + '''Entity rational_b_spline_curve definition. + + :param weights_data + :type weights_data:LIST(2,None,'REAL', scope = schema_scope) + + :param weights + :type weights:ARRAY(0,upper_index_on_control_points,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , weights_data, ): + b_spline_curve.__init__(self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , ) + self.weights_data = weights_data + + @apply + def weights_data(): + def fget( self ): + return self._weights_data + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument weights_data is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._weights_data = LIST(value) + else: + self._weights_data = value + return property(**locals()) + + @apply + def weights(): + def fget( self ): + attribute_eval = list_to_array(self.weights_data,0,self.upper_index_on_control_points) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument weights is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.weights_data) == SIZEOF(self.self.b_spline_curve.self.control_points_list)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = curve_weights_positive(self) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY topological_representation_item # +#################### +class topological_representation_item(representation_item): + '''Entity topological_representation_item definition. + ''' + def __init__( self , inherited0__name , ): + representation_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY edge # +#################### +class edge(topological_representation_item): + '''Entity edge definition. + + :param edge_start + :type edge_start:vertex + + :param edge_end + :type edge_end:vertex + ''' + def __init__( self , inherited0__name , edge_start,edge_end, ): + topological_representation_item.__init__(self , inherited0__name , ) + self.edge_start = edge_start + self.edge_end = edge_end + + @apply + def edge_start(): + def fget( self ): + return self._edge_start + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edge_start is mantatory and can not be set to None') + if not check_type(value,vertex): + self._edge_start = vertex(value) + else: + self._edge_start = value + return property(**locals()) + + @apply + def edge_end(): + def fget( self ): + return self._edge_end + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edge_end is mantatory and can not be set to None') + if not check_type(value,vertex): + self._edge_end = vertex(value) + else: + self._edge_end = value + return property(**locals()) + +#################### + # ENTITY subedge # +#################### +class subedge(edge): + '''Entity subedge definition. + + :param parent_edge + :type parent_edge:edge + ''' + def __init__( self , inherited0__name , inherited1__edge_start , inherited2__edge_end , parent_edge, ): + edge.__init__(self , inherited0__name , inherited1__edge_start , inherited2__edge_end , ) + self.parent_edge = parent_edge + + @apply + def parent_edge(): + def fget( self ): + return self._parent_edge + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parent_edge is mantatory and can not be set to None') + if not check_type(value,edge): + self._parent_edge = edge(value) + else: + self._parent_edge = value + return property(**locals()) + +#################### + # ENTITY comparison_expression # +#################### +class comparison_expression(boolean_expression,binary_generic_expression): + '''Entity comparison_expression definition. + + :param binary_generic_expression_operands + :type binary_generic_expression_operands:LIST(2,2,'expression', scope = schema_scope) + ''' + def __init__( self , inherited0__operands , binary_generic_expression_operands, ): + boolean_expression.__init__(self , ) + binary_generic_expression.__init__(self , inherited0__operands , ) + self.binary_generic_expression_operands = binary_generic_expression_operands + + @apply + def binary_generic_expression_operands(): + def fget( self ): + return self._binary_generic_expression_operands + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument binary_generic_expression_operands is mantatory and can not be set to None') + if not check_type(value,LIST(2,2,'expression', scope = schema_scope)): + self._binary_generic_expression_operands = LIST(value) + else: + self._binary_generic_expression_operands = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (((('AUTOMOTIVE_DESIGN.NUMERIC_EXPRESSION' == TYPEOF(self.self.binary_generic_expression.self.operands[1])) and ('AUTOMOTIVE_DESIGN.NUMERIC_EXPRESSION' == TYPEOF(self.self.binary_generic_expression.self.operands[2]))) or (('AUTOMOTIVE_DESIGN.BOOLEAN_EXPRESSION' == TYPEOF(self.self.binary_generic_expression.self.operands[1])) and ('AUTOMOTIVE_DESIGN.BOOLEAN_EXPRESSION' == TYPEOF(self.self.binary_generic_expression.self.operands[2])))) or (('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.self.binary_generic_expression.self.operands[1])) and ('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.self.binary_generic_expression.self.operands[2])))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY comparison_greater # +#################### +class comparison_greater(comparison_expression): + '''Entity comparison_greater definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + comparison_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY geometric_tolerance_with_datum_reference # +#################### +class geometric_tolerance_with_datum_reference(geometric_tolerance): + '''Entity geometric_tolerance_with_datum_reference definition. + + :param datum_system + :type datum_system:SET(1,None,'datum_reference', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , datum_system, ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + self.datum_system = datum_system + + @apply + def datum_system(): + def fget( self ): + return self._datum_system + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument datum_system is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'datum_reference', scope = schema_scope)): + self._datum_system = SET(value) + else: + self._datum_system = value + return property(**locals()) + +#################### + # ENTITY symmetry_tolerance # +#################### +class symmetry_tolerance(geometric_tolerance_with_datum_reference): + '''Entity symmetry_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ): + geometric_tolerance_with_datum_reference.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) <= 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY action_request_assignment # +#################### +class action_request_assignment(BaseEntityClass): + '''Entity action_request_assignment definition. + + :param assigned_action_request + :type assigned_action_request:versioned_action_request + + :param role + :type role:object_role + ''' + def __init__( self , assigned_action_request, ): + self.assigned_action_request = assigned_action_request + + @apply + def assigned_action_request(): + def fget( self ): + return self._assigned_action_request + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_action_request is mantatory and can not be set to None') + if not check_type(value,versioned_action_request): + self._assigned_action_request = versioned_action_request(value) + else: + self._assigned_action_request = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_area # +#################### +class applied_area(shape_aspect): + '''Entity applied_area definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY unary_boolean_expression # +#################### +class unary_boolean_expression(boolean_expression,unary_generic_expression): + '''Entity unary_boolean_expression definition. + ''' + def __init__( self , inherited0__operand , ): + boolean_expression.__init__(self , ) + unary_generic_expression.__init__(self , inherited0__operand , ) + +#################### + # ENTITY odd_function # +#################### +class odd_function(unary_boolean_expression): + '''Entity odd_function definition. + + :param unary_generic_expression_operand + :type unary_generic_expression_operand:numeric_expression + ''' + def __init__( self , inherited0__operand , unary_generic_expression_operand, ): + unary_boolean_expression.__init__(self , inherited0__operand , ) + self.unary_generic_expression_operand = unary_generic_expression_operand + + @apply + def unary_generic_expression_operand(): + def fget( self ): + return self._unary_generic_expression_operand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unary_generic_expression_operand is mantatory and can not be set to None') + if not check_type(value,numeric_expression): + self._unary_generic_expression_operand = numeric_expression(value) + else: + self._unary_generic_expression_operand = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = is_int_expr(self) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY dimensional_location # +#################### +class dimensional_location(shape_aspect_relationship): + '''Entity dimensional_location definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ): + shape_aspect_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + +#################### + # ENTITY directed_dimensional_location # +#################### +class directed_dimensional_location(dimensional_location): + '''Entity directed_dimensional_location definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ): + dimensional_location.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + +#################### + # ENTITY context_dependent_unit # +#################### +class context_dependent_unit(named_unit): + '''Entity context_dependent_unit definition. + + :param name + :type name:label + ''' + def __init__( self , inherited0__dimensions , name, ): + named_unit.__init__(self , inherited0__dimensions , ) + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY variable_semantics # +#################### +class variable_semantics(BaseEntityClass): + '''Entity variable_semantics definition. + ''' + # This class does not define any attribute. + pass + +#################### + # ENTITY expression_conversion_based_unit # +#################### +class expression_conversion_based_unit(context_dependent_unit,variable_semantics): + '''Entity expression_conversion_based_unit definition. + + :param associated_variable_environment + :type associated_variable_environment:environment + ''' + def __init__( self , inherited0__dimensions , inherited1__name , ): + context_dependent_unit.__init__(self , inherited0__dimensions , inherited1__name , ) + variable_semantics.__init__(self , ) + + @apply + def associated_variable_environment(): + def fget( self ): + return self._associated_variable_environment + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument associated_variable_environment is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY face_bound # +#################### +class face_bound(topological_representation_item): + '''Entity face_bound definition. + + :param bound + :type bound:loop + + :param orientation + :type orientation:BOOLEAN + ''' + def __init__( self , inherited0__name , bound,orientation, ): + topological_representation_item.__init__(self , inherited0__name , ) + self.bound = bound + self.orientation = orientation + + @apply + def bound(): + def fget( self ): + return self._bound + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bound is mantatory and can not be set to None') + if not check_type(value,loop): + self._bound = loop(value) + else: + self._bound = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + +#################### + # ENTITY length_measure_with_unit # +#################### +class length_measure_with_unit(measure_with_unit): + '''Entity length_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.LENGTH_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY text_string_representation # +#################### +class text_string_representation(representation): + '''Entity text_string_representation definition. + + :param representation_items + :type representation_items:SET(1,None,'text_string_representation_item', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , representation_items, ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + self.representation_items = representation_items + + @apply + def representation_items(): + def fget( self ): + return self._representation_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'text_string_representation_item', scope = schema_scope)): + self._representation_items = SET(value) + else: + self._representation_items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) >= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY annotation_subfigure_occurrence # +#################### +class annotation_subfigure_occurrence(annotation_symbol_occurrence): + '''Entity annotation_subfigure_occurrence definition. + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , ): + annotation_symbol_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ('AUTOMOTIVE_DESIGN.ANNOTATION_SYMBOL' == TYPEOF(self.self.item)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ('AUTOMOTIVE_DESIGN.DRAUGHTING_SUBFIGURE_REPRESENTATION' == TYPEOF(self.self.item.self.mapped_item.self.mapping_source.self.mapped_representation)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY data_environment # +#################### +class data_environment(BaseEntityClass): + '''Entity data_environment definition. + + :param name + :type name:label + + :param description + :type description:text + + :param elements + :type elements:SET(1,None,'property_definition_representation', scope = schema_scope) + ''' + def __init__( self , name,description,elements, ): + self.name = name + self.description = description + self.elements = elements + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def elements(): + def fget( self ): + return self._elements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument elements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'property_definition_representation', scope = schema_scope)): + self._elements = SET(value) + else: + self._elements = value + return property(**locals()) + +#################### + # ENTITY format_function # +#################### +class format_function(string_expression,binary_generic_expression): + '''Entity format_function definition. + + :param value_to_format + :type value_to_format:generic_expression + + :param format_string + :type format_string:generic_expression + ''' + def __init__( self , inherited0__operands , ): + string_expression.__init__(self , ) + binary_generic_expression.__init__(self , inherited0__operands , ) + + @apply + def value_to_format(): + def fget( self ): + attribute_eval = self.self.binary_generic_expression.self.operands[1] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument value_to_format is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def format_string(): + def fget( self ): + attribute_eval = self.self.binary_generic_expression.self.operands[2] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument format_string is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.NUMERIC_EXPRESSION' == TYPEOF(self.value_to_format)) and ('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.format_string))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY visual_appearance_representation # +#################### +class visual_appearance_representation(representation): + '''Entity visual_appearance_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (((2 <= SIZEOF(self.self.items)) and (SIZEOF(self.self.items) <= 5)) and (SIZEOF(None) == SIZEOF(self.self.items))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) <= 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) <= 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) <= 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.USED_REPRESENTATION')) == 1) and (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY dated_effectivity # +#################### +class dated_effectivity(effectivity): + '''Entity dated_effectivity definition. + + :param effectivity_end_date + :type effectivity_end_date:date_time_or_event_occurrence + + :param effectivity_start_date + :type effectivity_start_date:date_time_or_event_occurrence + ''' + def __init__( self , inherited0__id , effectivity_end_date,effectivity_start_date, ): + effectivity.__init__(self , inherited0__id , ) + self.effectivity_end_date = effectivity_end_date + self.effectivity_start_date = effectivity_start_date + + @apply + def effectivity_end_date(): + def fget( self ): + return self._effectivity_end_date + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,date_time_or_event_occurrence): + self._effectivity_end_date = date_time_or_event_occurrence(value) + else: + self._effectivity_end_date = value + else: + self._effectivity_end_date = value + return property(**locals()) + + @apply + def effectivity_start_date(): + def fget( self ): + return self._effectivity_start_date + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument effectivity_start_date is mantatory and can not be set to None') + if not check_type(value,date_time_or_event_occurrence): + self._effectivity_start_date = date_time_or_event_occurrence(value) + else: + self._effectivity_start_date = value + return property(**locals()) + +#################### + # ENTITY direction # +#################### +class direction(geometric_representation_item): + '''Entity direction definition. + + :param direction_ratios + :type direction_ratios:LIST(2,3,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__name , direction_ratios, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.direction_ratios = direction_ratios + + @apply + def direction_ratios(): + def fget( self ): + return self._direction_ratios + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument direction_ratios is mantatory and can not be set to None') + if not check_type(value,LIST(2,3,'REAL', scope = schema_scope)): + self._direction_ratios = LIST(value) + else: + self._direction_ratios = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY kinematic_analysis_result # +#################### +class kinematic_analysis_result(BaseEntityClass): + '''Entity kinematic_analysis_result definition. + + :param analysed_mechanism + :type analysed_mechanism:mechanism + + :param contained_kinematic_results + :type contained_kinematic_results:SET(1,None,'kinematic_result', scope = schema_scope) + ''' + def __init__( self , analysed_mechanism,contained_kinematic_results, ): + self.analysed_mechanism = analysed_mechanism + self.contained_kinematic_results = contained_kinematic_results + + @apply + def analysed_mechanism(): + def fget( self ): + return self._analysed_mechanism + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument analysed_mechanism is mantatory and can not be set to None') + if not check_type(value,mechanism): + self._analysed_mechanism = mechanism(value) + else: + self._analysed_mechanism = value + return property(**locals()) + + @apply + def contained_kinematic_results(): + def fget( self ): + return self._contained_kinematic_results + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument contained_kinematic_results is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'kinematic_result', scope = schema_scope)): + self._contained_kinematic_results = SET(value) + else: + self._contained_kinematic_results = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((SIZEOF(None) > 0) XOR (SIZEOF(None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY kinematic_link # +#################### +class kinematic_link(BaseEntityClass): + '''Entity kinematic_link definition. + ''' + # This class does not define any attribute. + pass + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.KINEMATIC_JOINT.FIRST_LINK') + USEDIN(self,'AUTOMOTIVE_DESIGN.KINEMATIC_JOINT.SECOND_LINK')) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = unique_link_usage(self) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY product_concept # +#################### +class product_concept(BaseEntityClass): + '''Entity product_concept definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + + :param market_context + :type market_context:product_concept_context + ''' + def __init__( self , id,name,description,market_context, ): + self.id = id + self.name = name + self.description = description + self.market_context = market_context + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def market_context(): + def fget( self ): + return self._market_context + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument market_context is mantatory and can not be set to None') + if not check_type(value,product_concept_context): + self._market_context = product_concept_context(value) + else: + self._market_context = value + return property(**locals()) + +#################### + # ENTITY product_class # +#################### +class product_class(product_concept,characterized_object): + '''Entity product_class definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__market_context , inherited4__name , inherited5__description , ): + product_concept.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__market_context , ) + characterized_object.__init__(self , inherited4__name , inherited5__description , ) + +#################### + # ENTITY text_style_for_defined_font # +#################### +class text_style_for_defined_font(BaseEntityClass): + '''Entity text_style_for_defined_font definition. + + :param text_colour + :type text_colour:colour + ''' + def __init__( self , text_colour, ): + self.text_colour = text_colour + + @apply + def text_colour(): + def fget( self ): + return self._text_colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument text_colour is mantatory and can not be set to None') + if not check_type(value,colour): + self._text_colour = colour(value) + else: + self._text_colour = value + return property(**locals()) + +#################### + # ENTITY light_source # +#################### +class light_source(geometric_representation_item): + '''Entity light_source definition. + + :param light_colour + :type light_colour:colour + ''' + def __init__( self , inherited0__name , light_colour, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.light_colour = light_colour + + @apply + def light_colour(): + def fget( self ): + return self._light_colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument light_colour is mantatory and can not be set to None') + if not check_type(value,colour): + self._light_colour = colour(value) + else: + self._light_colour = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.STYLED_ITEM.ITEM')) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY light_source_positional # +#################### +class light_source_positional(light_source): + '''Entity light_source_positional definition. + + :param position + :type position:cartesian_point + + :param constant_attenuation + :type constant_attenuation:REAL + + :param distance_attenuation + :type distance_attenuation:REAL + ''' + def __init__( self , inherited0__name , inherited1__light_colour , position,constant_attenuation,distance_attenuation, ): + light_source.__init__(self , inherited0__name , inherited1__light_colour , ) + self.position = position + self.constant_attenuation = constant_attenuation + self.distance_attenuation = distance_attenuation + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._position = cartesian_point(value) + else: + self._position = value + return property(**locals()) + + @apply + def constant_attenuation(): + def fget( self ): + return self._constant_attenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constant_attenuation is mantatory and can not be set to None') + if not check_type(value,REAL): + self._constant_attenuation = REAL(value) + else: + self._constant_attenuation = value + return property(**locals()) + + @apply + def distance_attenuation(): + def fget( self ): + return self._distance_attenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distance_attenuation is mantatory and can not be set to None') + if not check_type(value,REAL): + self._distance_attenuation = REAL(value) + else: + self._distance_attenuation = value + return property(**locals()) + +#################### + # ENTITY boolean_result # +#################### +class boolean_result(geometric_representation_item): + '''Entity boolean_result definition. + + :param operator + :type operator:boolean_operator + + :param first_operand + :type first_operand:boolean_operand + + :param second_operand + :type second_operand:boolean_operand + ''' + def __init__( self , inherited0__name , operator,first_operand,second_operand, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.operator = operator + self.first_operand = first_operand + self.second_operand = second_operand + + @apply + def operator(): + def fget( self ): + return self._operator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operator is mantatory and can not be set to None') + if not check_type(value,boolean_operator): + self._operator = boolean_operator(value) + else: + self._operator = value + return property(**locals()) + + @apply + def first_operand(): + def fget( self ): + return self._first_operand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument first_operand is mantatory and can not be set to None') + if not check_type(value,boolean_operand): + self._first_operand = boolean_operand(value) + else: + self._first_operand = value + return property(**locals()) + + @apply + def second_operand(): + def fget( self ): + return self._second_operand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument second_operand is mantatory and can not be set to None') + if not check_type(value,boolean_operand): + self._second_operand = boolean_operand(value) + else: + self._second_operand = value + return property(**locals()) + +#################### + # ENTITY group_relationship # +#################### +class group_relationship(BaseEntityClass): + '''Entity group_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_group + :type relating_group:group + + :param related_group + :type related_group:group + ''' + def __init__( self , name,description,relating_group,related_group, ): + self.name = name + self.description = description + self.relating_group = relating_group + self.related_group = related_group + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_group(): + def fget( self ): + return self._relating_group + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_group is mantatory and can not be set to None') + if not check_type(value,group): + self._relating_group = group(value) + else: + self._relating_group = value + return property(**locals()) + + @apply + def related_group(): + def fget( self ): + return self._related_group + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_group is mantatory and can not be set to None') + if not check_type(value,group): + self._related_group = group(value) + else: + self._related_group = value + return property(**locals()) + +#################### + # ENTITY item_identified_representation_usage # +#################### +class item_identified_representation_usage(BaseEntityClass): + '''Entity item_identified_representation_usage definition. + + :param name + :type name:label + + :param description + :type description:text + + :param definition + :type definition:represented_definition + + :param used_representation + :type used_representation:representation + + :param identified_item + :type identified_item:representation_item + ''' + def __init__( self , name,description,definition,used_representation,identified_item, ): + self.name = name + self.description = description + self.definition = definition + self.used_representation = used_representation + self.identified_item = identified_item + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definition is mantatory and can not be set to None') + if not check_type(value,represented_definition): + self._definition = represented_definition(value) + else: + self._definition = value + return property(**locals()) + + @apply + def used_representation(): + def fget( self ): + return self._used_representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument used_representation is mantatory and can not be set to None') + if not check_type(value,representation): + self._used_representation = representation(value) + else: + self._used_representation = value + return property(**locals()) + + @apply + def identified_item(): + def fget( self ): + return self._identified_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument identified_item is mantatory and can not be set to None') + if not check_type(value,representation_item): + self._identified_item = representation_item(value) + else: + self._identified_item = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.used_representation == using_representations(self.self.identified_item)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_definition_formation_relationship # +#################### +class product_definition_formation_relationship(BaseEntityClass): + '''Entity product_definition_formation_relationship definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + + :param relating_product_definition_formation + :type relating_product_definition_formation:product_definition_formation + + :param related_product_definition_formation + :type related_product_definition_formation:product_definition_formation + ''' + def __init__( self , id,name,description,relating_product_definition_formation,related_product_definition_formation, ): + self.id = id + self.name = name + self.description = description + self.relating_product_definition_formation = relating_product_definition_formation + self.related_product_definition_formation = related_product_definition_formation + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_product_definition_formation(): + def fget( self ): + return self._relating_product_definition_formation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_product_definition_formation is mantatory and can not be set to None') + if not check_type(value,product_definition_formation): + self._relating_product_definition_formation = product_definition_formation(value) + else: + self._relating_product_definition_formation = value + return property(**locals()) + + @apply + def related_product_definition_formation(): + def fget( self ): + return self._related_product_definition_formation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_product_definition_formation is mantatory and can not be set to None') + if not check_type(value,product_definition_formation): + self._related_product_definition_formation = product_definition_formation(value) + else: + self._related_product_definition_formation = value + return property(**locals()) + +#################### + # ENTITY representation_relationship # +#################### +class representation_relationship(BaseEntityClass): + '''Entity representation_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param rep_1 + :type rep_1:representation + + :param rep_2 + :type rep_2:representation + ''' + def __init__( self , name,description,rep_1,rep_2, ): + self.name = name + self.description = description + self.rep_1 = rep_1 + self.rep_2 = rep_2 + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def rep_1(): + def fget( self ): + return self._rep_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rep_1 is mantatory and can not be set to None') + if not check_type(value,representation): + self._rep_1 = representation(value) + else: + self._rep_1 = value + return property(**locals()) + + @apply + def rep_2(): + def fget( self ): + return self._rep_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rep_2 is mantatory and can not be set to None') + if not check_type(value,representation): + self._rep_2 = representation(value) + else: + self._rep_2 = value + return property(**locals()) + +#################### + # ENTITY motion_link_relationship # +#################### +class motion_link_relationship(representation_relationship): + '''Entity motion_link_relationship definition. + + :param representation_relationship_rep_1 + :type representation_relationship_rep_1:founded_kinematic_path + + :param representation_relationship_rep_2 + :type representation_relationship_rep_2:kinematic_link_representation + + :param related_frame + :type related_frame:rigid_placement + + :param motion + :type motion:founded_kinematic_path + + :param frame_link + :type frame_link:kinematic_link_representation + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , representation_relationship_rep_1,representation_relationship_rep_2,related_frame, ): + representation_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , ) + self.representation_relationship_rep_1 = representation_relationship_rep_1 + self.representation_relationship_rep_2 = representation_relationship_rep_2 + self.related_frame = related_frame + + @apply + def representation_relationship_rep_1(): + def fget( self ): + return self._representation_relationship_rep_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_relationship_rep_1 is mantatory and can not be set to None') + if not check_type(value,founded_kinematic_path): + self._representation_relationship_rep_1 = founded_kinematic_path(value) + else: + self._representation_relationship_rep_1 = value + return property(**locals()) + + @apply + def representation_relationship_rep_2(): + def fget( self ): + return self._representation_relationship_rep_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_relationship_rep_2 is mantatory and can not be set to None') + if not check_type(value,kinematic_link_representation): + self._representation_relationship_rep_2 = kinematic_link_representation(value) + else: + self._representation_relationship_rep_2 = value + return property(**locals()) + + @apply + def related_frame(): + def fget( self ): + return self._related_frame + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_frame is mantatory and can not be set to None') + if not check_type(value,rigid_placement): + self._related_frame = rigid_placement(value) + else: + self._related_frame = value + return property(**locals()) + + @apply + def motion(): + def fget( self ): + attribute_eval = self.self.representation_relationship.self.rep_1 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument motion is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def frame_link(): + def fget( self ): + attribute_eval = self.self.representation_relationship.self.rep_2 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument frame_link is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.related_frame == self.frame_link.self.representation.self.items) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY universal_pair # +#################### +class universal_pair(kinematic_pair): + '''Entity universal_pair definition. + + :param input_skew_angle + :type input_skew_angle:plane_angle_measure + + :param skew_angle + :type skew_angle:plane_angle_measure + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , input_skew_angle, ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + self.input_skew_angle = input_skew_angle + + @apply + def input_skew_angle(): + def fget( self ): + return self._input_skew_angle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,plane_angle_measure): + self._input_skew_angle = plane_angle_measure(value) + else: + self._input_skew_angle = value + else: + self._input_skew_angle = value + return property(**locals()) + + @apply + def skew_angle(): + def fget( self ): + attribute_eval = NVL(self.input_skew_angle,0) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument skew_angle is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (COS(plane_angle_for_pair_in_radian(self,self.skew_angle)) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY event_occurrence_assignment # +#################### +class event_occurrence_assignment(BaseEntityClass): + '''Entity event_occurrence_assignment definition. + + :param assigned_event_occurrence + :type assigned_event_occurrence:event_occurrence + + :param role + :type role:event_occurrence_role + ''' + def __init__( self , assigned_event_occurrence,role, ): + self.assigned_event_occurrence = assigned_event_occurrence + self.role = role + + @apply + def assigned_event_occurrence(): + def fget( self ): + return self._assigned_event_occurrence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_event_occurrence is mantatory and can not be set to None') + if not check_type(value,event_occurrence): + self._assigned_event_occurrence = event_occurrence(value) + else: + self._assigned_event_occurrence = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,event_occurrence_role): + self._role = event_occurrence_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY applied_event_occurrence_assignment # +#################### +class applied_event_occurrence_assignment(event_occurrence_assignment): + '''Entity applied_event_occurrence_assignment definition. + + :param items + :type items:SET(1,None,'event_occurrence_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_event_occurrence , inherited1__role , items, ): + event_occurrence_assignment.__init__(self , inherited0__assigned_event_occurrence , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'event_occurrence_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY camera_model_d2 # +#################### +class camera_model_d2(camera_model): + '''Entity camera_model_d2 definition. + + :param view_window + :type view_window:planar_box + + :param view_window_clipping + :type view_window_clipping:BOOLEAN + ''' + def __init__( self , inherited0__name , view_window,view_window_clipping, ): + camera_model.__init__(self , inherited0__name , ) + self.view_window = view_window + self.view_window_clipping = view_window_clipping + + @apply + def view_window(): + def fget( self ): + return self._view_window + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument view_window is mantatory and can not be set to None') + if not check_type(value,planar_box): + self._view_window = planar_box(value) + else: + self._view_window = value + return property(**locals()) + + @apply + def view_window_clipping(): + def fget( self ): + return self._view_window_clipping + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument view_window_clipping is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._view_window_clipping = BOOLEAN(value) + else: + self._view_window_clipping = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.geometric_representation_item.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ( not ('AUTOMOTIVE_DESIGN.CAMERA_IMAGE_2D_WITH_SCALE' == TYPEOF(self))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY group_assignment # +#################### +class group_assignment(BaseEntityClass): + '''Entity group_assignment definition. + + :param assigned_group + :type assigned_group:group + + :param role + :type role:object_role + ''' + def __init__( self , assigned_group, ): + self.assigned_group = assigned_group + + @apply + def assigned_group(): + def fget( self ): + return self._assigned_group + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_group is mantatory and can not be set to None') + if not check_type(value,group): + self._assigned_group = group(value) + else: + self._assigned_group = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY next_assembly_usage_occurrence # +#################### +class next_assembly_usage_occurrence(assembly_component_usage): + '''Entity next_assembly_usage_occurrence definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , inherited5__reference_designator , ): + assembly_component_usage.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , inherited5__reference_designator , ) + +#################### + # ENTITY prismatic_pair_value # +#################### +class prismatic_pair_value(pair_value): + '''Entity prismatic_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:prismatic_pair + + :param actual_translation + :type actual_translation:length_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_translation, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_translation = actual_translation + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,prismatic_pair): + self._pair_value_applies_to_pair = prismatic_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_translation(): + def fget( self ): + return self._actual_translation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_translation is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._actual_translation = length_measure(value) + else: + self._actual_translation = value + return property(**locals()) + +#################### + # ENTITY rolling_surface_pair_value # +#################### +class rolling_surface_pair_value(pair_value): + '''Entity rolling_surface_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:rolling_surface_pair + + :param actual_point_on_surface + :type actual_point_on_surface:point_on_surface + + :param actual_rotation + :type actual_rotation:plane_angle_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_point_on_surface,actual_rotation, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_point_on_surface = actual_point_on_surface + self.actual_rotation = actual_rotation + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,rolling_surface_pair): + self._pair_value_applies_to_pair = rolling_surface_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_point_on_surface(): + def fget( self ): + return self._actual_point_on_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_point_on_surface is mantatory and can not be set to None') + if not check_type(value,point_on_surface): + self._actual_point_on_surface = point_on_surface(value) + else: + self._actual_point_on_surface = value + return property(**locals()) + + @apply + def actual_rotation(): + def fget( self ): + return self._actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_rotation is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._actual_rotation = plane_angle_measure(value) + else: + self._actual_rotation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.pair_value.self.applies_to_pair.self.surface_pair.self.surface_1 == self.actual_point_on_surface.self.basis_surface) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY time_unit # +#################### +class time_unit(named_unit): + '''Entity time_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 0) and (self.self.named_unit.self.dimensions.self.mass_exponent == 0)) and (self.self.named_unit.self.dimensions.self.time_exponent == 1)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 0)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 0)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 0)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY camera_model_d3 # +#################### +class camera_model_d3(camera_model): + '''Entity camera_model_d3 definition. + + :param view_reference_system + :type view_reference_system:axis2_placement_3d + + :param perspective_of_volume + :type perspective_of_volume:view_volume + ''' + def __init__( self , inherited0__name , view_reference_system,perspective_of_volume, ): + camera_model.__init__(self , inherited0__name , ) + self.view_reference_system = view_reference_system + self.perspective_of_volume = perspective_of_volume + + @apply + def view_reference_system(): + def fget( self ): + return self._view_reference_system + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument view_reference_system is mantatory and can not be set to None') + if not check_type(value,axis2_placement_3d): + self._view_reference_system = axis2_placement_3d(value) + else: + self._view_reference_system = value + return property(**locals()) + + @apply + def perspective_of_volume(): + def fget( self ): + return self._perspective_of_volume + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument perspective_of_volume is mantatory and can not be set to None') + if not check_type(value,view_volume): + self._perspective_of_volume = view_volume(value) + else: + self._perspective_of_volume = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((dot_product(self.self.view_reference_system.self.p[3],self.self.perspective_of_volume.self.view_window.self.placement.self.p[3]) == 1) and (self.self.view_reference_system.self.location.self.coordinates[3] == self.self.perspective_of_volume.self.view_window.self.placement.self.location.self.coordinates[3])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.geometric_representation_item.self.dim == 3) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY interval_expression # +#################### +class interval_expression(boolean_expression,multiple_arity_generic_expression): + '''Entity interval_expression definition. + + :param interval_low + :type interval_low:generic_expression + + :param interval_item + :type interval_item:generic_expression + + :param interval_high + :type interval_high:generic_expression + ''' + def __init__( self , inherited0__operands , ): + boolean_expression.__init__(self , ) + multiple_arity_generic_expression.__init__(self , inherited0__operands , ) + + @apply + def interval_low(): + def fget( self ): + attribute_eval = self.self.multiple_arity_generic_expression.self.operands[1] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument interval_low is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def interval_item(): + def fget( self ): + attribute_eval = self.self.multiple_arity_generic_expression.self.operands[2] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument interval_item is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def interval_high(): + def fget( self ): + attribute_eval = self.self.multiple_arity_generic_expression.self.operands[3] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument interval_high is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.EXPRESSION' == TYPEOF(self.interval_low)) and ('AUTOMOTIVE_DESIGN.EXPRESSION' == TYPEOF(self.interval_item))) and ('AUTOMOTIVE_DESIGN.EXPRESSION' == TYPEOF(self.interval_high))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (((('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.self.interval_low)) and ('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.self.interval_high))) and ('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.self.interval_item))) or ((('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.self.interval_low)) and ('AUTOMOTIVE_DESIGN.NUMERIC_EXPRESSION' == TYPEOF(self.self.interval_item))) and ('AUTOMOTIVE_DESIGN.NUMERIC_EXPRESSION' == TYPEOF(self.self.interval_high)))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY oriented_edge # +#################### +class oriented_edge(edge): + '''Entity oriented_edge definition. + + :param edge_element + :type edge_element:edge + + :param orientation + :type orientation:BOOLEAN + + :param edge_edge_start + :type edge_edge_start:vertex + + :param edge_edge_end + :type edge_edge_end:vertex + ''' + def __init__( self , inherited0__name , inherited1__edge_start , inherited2__edge_end , edge_element,orientation, ): + edge.__init__(self , inherited0__name , inherited1__edge_start , inherited2__edge_end , ) + self.edge_element = edge_element + self.orientation = orientation + + @apply + def edge_element(): + def fget( self ): + return self._edge_element + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edge_element is mantatory and can not be set to None') + if not check_type(value,edge): + self._edge_element = edge(value) + else: + self._edge_element = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def edge_edge_start(): + def fget( self ): + attribute_eval = boolean_choose(self.self.orientation,self.self.edge_element.self.edge_start,self.self.edge_element.self.edge_end) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument edge_edge_start is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def edge_edge_end(): + def fget( self ): + attribute_eval = boolean_choose(self.self.orientation,self.self.edge_element.self.edge_end,self.self.edge_element.self.edge_start) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument edge_edge_end is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('AUTOMOTIVE_DESIGN.ORIENTED_EDGE' == TYPEOF(self.self.edge_element))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY person # +#################### +class person(BaseEntityClass): + '''Entity person definition. + + :param id + :type id:identifier + + :param last_name + :type last_name:label + + :param first_name + :type first_name:label + + :param middle_names + :type middle_names:LIST(1,None,'STRING', scope = schema_scope) + + :param prefix_titles + :type prefix_titles:LIST(1,None,'STRING', scope = schema_scope) + + :param suffix_titles + :type suffix_titles:LIST(1,None,'STRING', scope = schema_scope) + ''' + def __init__( self , id,last_name,first_name,middle_names,prefix_titles,suffix_titles, ): + self.id = id + self.last_name = last_name + self.first_name = first_name + self.middle_names = middle_names + self.prefix_titles = prefix_titles + self.suffix_titles = suffix_titles + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def last_name(): + def fget( self ): + return self._last_name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._last_name = label(value) + else: + self._last_name = value + else: + self._last_name = value + return property(**locals()) + + @apply + def first_name(): + def fget( self ): + return self._first_name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._first_name = label(value) + else: + self._first_name = value + else: + self._first_name = value + return property(**locals()) + + @apply + def middle_names(): + def fget( self ): + return self._middle_names + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._middle_names = LIST(value) + else: + self._middle_names = value + else: + self._middle_names = value + return property(**locals()) + + @apply + def prefix_titles(): + def fget( self ): + return self._prefix_titles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._prefix_titles = LIST(value) + else: + self._prefix_titles = value + else: + self._prefix_titles = value + return property(**locals()) + + @apply + def suffix_titles(): + def fget( self ): + return self._suffix_titles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._suffix_titles = LIST(value) + else: + self._suffix_titles = value + else: + self._suffix_titles = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (EXISTS(self.last_name) or EXISTS(self.first_name)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY camera_image # +#################### +class camera_image(mapped_item): + '''Entity camera_image definition. + + :param mapped_item_mapping_source + :type mapped_item_mapping_source:camera_usage + + :param mapped_item_mapping_target + :type mapped_item_mapping_target:planar_box + ''' + def __init__( self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , mapped_item_mapping_source,mapped_item_mapping_target, ): + mapped_item.__init__(self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , ) + self.mapped_item_mapping_source = mapped_item_mapping_source + self.mapped_item_mapping_target = mapped_item_mapping_target + + @apply + def mapped_item_mapping_source(): + def fget( self ): + return self._mapped_item_mapping_source + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapped_item_mapping_source is mantatory and can not be set to None') + if not check_type(value,camera_usage): + self._mapped_item_mapping_source = camera_usage(value) + else: + self._mapped_item_mapping_source = value + return property(**locals()) + + @apply + def mapped_item_mapping_target(): + def fget( self ): + return self._mapped_item_mapping_target + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapped_item_mapping_target is mantatory and can not be set to None') + if not check_type(value,planar_box): + self._mapped_item_mapping_target = planar_box(value) + else: + self._mapped_item_mapping_target = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.GEOMETRIC_REPRESENTATION_ITEM' == TYPEOF(self)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY camera_image_3d_with_scale # +#################### +class camera_image_3d_with_scale(camera_image): + '''Entity camera_image_3d_with_scale definition. + + :param scale + :type scale:positive_ratio_measure + ''' + def __init__( self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , inherited3__mapped_item_mapping_source , inherited4__mapped_item_mapping_target , ): + camera_image.__init__(self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , inherited3__mapped_item_mapping_source , inherited4__mapped_item_mapping_target , ) + + @apply + def scale(): + def fget( self ): + attribute_eval = (self.self.mapped_item.self.mapping_target.self.planar_extent.self.size_in_x / self.self.mapped_item.self.mapping_source.self.mapping_origin.self.camera_model_d3.self.perspective_of_volume.self.view_window.self.size_in_x) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scale is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.CAMERA_MODEL_D3' == TYPEOF(self.self.mapped_item.self.mapping_source.self.mapping_origin)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (aspect_ratio(self.self.mapped_item.self.mapping_target) == aspect_ratio(self.self.mapped_item.self.mapping_source.self.mapping_origin.self.camera_model_d3.self.perspective_of_volume.self.view_window)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.self.mapped_item.self.mapping_source.self.mapping_origin.self.camera_model_d3.self.perspective_of_volume.self.front_plane_clipping and self.self.mapped_item.self.mapping_source.self.mapping_origin.self.camera_model_d3.self.perspective_of_volume.self.view_volume_sides_clipping) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.mapped_item.self.mapping_target.self.planar_extent.self.size_in_x > 0) and (self.self.mapped_item.self.mapping_target.self.planar_extent.self.size_in_y > 0)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.mapped_item.self.mapping_source.self.mapping_origin.self.camera_model_d3.self.perspective_of_volume.self.view_window.self.size_in_x > 0) and (self.self.mapped_item.self.mapping_source.self.mapping_origin.self.camera_model_d3.self.perspective_of_volume.self.view_window.self.size_in_y > 0)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((('AUTOMOTIVE_DESIGN.' + 'AXIS2_PLACEMENT_2D') == TYPEOF(self.self.mapped_item.self.mapping_target.self.planar_box.self.placement)) and ( not (('AUTOMOTIVE_DESIGN.' + 'AXIS2_PLACEMENT_3D') == TYPEOF(self.self.mapped_item.self.mapping_target.self.planar_box.self.placement)))) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + +#################### + # ENTITY effectivity_assignment # +#################### +class effectivity_assignment(BaseEntityClass): + '''Entity effectivity_assignment definition. + + :param assigned_effectivity + :type assigned_effectivity:effectivity + + :param role + :type role:object_role + ''' + def __init__( self , assigned_effectivity, ): + self.assigned_effectivity = assigned_effectivity + + @apply + def assigned_effectivity(): + def fget( self ): + return self._assigned_effectivity + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_effectivity is mantatory and can not be set to None') + if not check_type(value,effectivity): + self._assigned_effectivity = effectivity(value) + else: + self._assigned_effectivity = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY configured_effectivity_assignment # +#################### +class configured_effectivity_assignment(effectivity_assignment): + '''Entity configured_effectivity_assignment definition. + + :param items + :type items:SET(1,None,'configured_effectivity_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_effectivity , items, ): + effectivity_assignment.__init__(self , inherited0__assigned_effectivity , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'configured_effectivity_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((SIZEOF(['AUTOMOTIVE_DESIGN.' + 'EFFECTIVITY'] * TYPEOF(self.self.assigned_effectivity)) == 1) and (self.self.assigned_effectivity.self.id == 'configuration validity')) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(self.self.items) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (self.self.role.self.name == ['design','usage']) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.role.self.name != 'design') or (SIZEOF(None) == 0)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.role.self.name != 'usage') or (SIZEOF(None) == 0)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (self.self.role.self.description == ['exception','inherited','local']) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + +#################### + # ENTITY classification_assignment # +#################### +class classification_assignment(BaseEntityClass): + '''Entity classification_assignment definition. + + :param assigned_class + :type assigned_class:group + + :param role + :type role:classification_role + ''' + def __init__( self , assigned_class,role, ): + self.assigned_class = assigned_class + self.role = role + + @apply + def assigned_class(): + def fget( self ): + return self._assigned_class + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_class is mantatory and can not be set to None') + if not check_type(value,group): + self._assigned_class = group(value) + else: + self._assigned_class = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,classification_role): + self._role = classification_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY language_assignment # +#################### +class language_assignment(classification_assignment): + '''Entity language_assignment definition. + + :param items + :type items:SET(1,None,'language_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_class , inherited1__role , items, ): + classification_assignment.__init__(self , inherited0__assigned_class , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'language_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'LANGUAGE') == TYPEOF(self.self.assigned_class)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.role.self.name == 'language') + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(self.self.items) == SIZEOF(None)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY action # +#################### +class action(BaseEntityClass): + '''Entity action definition. + + :param name + :type name:label + + :param description + :type description:text + + :param chosen_method + :type chosen_method:action_method + + :param id + :type id:identifier + ''' + def __init__( self , name,description,chosen_method, ): + self.name = name + self.description = description + self.chosen_method = chosen_method + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def chosen_method(): + def fget( self ): + return self._chosen_method + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument chosen_method is mantatory and can not be set to None') + if not check_type(value,action_method): + self._chosen_method = action_method(value) + else: + self._chosen_method = value + return property(**locals()) + + @apply + def id(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument id is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY property_process # +#################### +class property_process(action): + '''Entity property_process definition. + + :param identification + :type identification:identifier + + :param properties + :type properties:SET(1,None,'process_property_association', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__chosen_method , identification, ): + action.__init__(self , inherited0__name , inherited1__description , inherited2__chosen_method , ) + self.identification = identification + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument identification is mantatory and can not be set to None') + if not check_type(value,identifier): + self._identification = identifier(value) + else: + self._identification = value + return property(**locals()) + + @apply + def properties(): + def fget( self ): + return self._properties + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument properties is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY swept_area_solid # +#################### +class swept_area_solid(solid_model): + '''Entity swept_area_solid definition. + + :param swept_area + :type swept_area:curve_bounded_surface + ''' + def __init__( self , inherited0__name , swept_area, ): + solid_model.__init__(self , inherited0__name , ) + self.swept_area = swept_area + + @apply + def swept_area(): + def fget( self ): + return self._swept_area + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument swept_area is mantatory and can not be set to None') + if not check_type(value,curve_bounded_surface): + self._swept_area = curve_bounded_surface(value) + else: + self._swept_area = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.PLANE' == TYPEOF(self.swept_area.self.basis_surface)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY revolved_area_solid # +#################### +class revolved_area_solid(swept_area_solid): + '''Entity revolved_area_solid definition. + + :param axis + :type axis:axis1_placement + + :param angle + :type angle:plane_angle_measure + + :param axis_line + :type axis_line:line + ''' + def __init__( self , inherited0__name , inherited1__swept_area , axis,angle, ): + swept_area_solid.__init__(self , inherited0__name , inherited1__swept_area , ) + self.axis = axis + self.angle = angle + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axis is mantatory and can not be set to None') + if not check_type(value,axis1_placement): + self._axis = axis1_placement(value) + else: + self._axis = value + return property(**locals()) + + @apply + def angle(): + def fget( self ): + return self._angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument angle is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._angle = plane_angle_measure(value) + else: + self._angle = value + return property(**locals()) + + @apply + def axis_line(): + def fget( self ): + attribute_eval = (((representation_item('') == geometric_representation_item()) == curve()) == line(self.axis.self.location,(representation_item('') == geometric_representation_item()) == vector(self.axis.self.z,1))) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument axis_line is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY conversion_based_unit # +#################### +class conversion_based_unit(named_unit): + '''Entity conversion_based_unit definition. + + :param name + :type name:label + + :param conversion_factor + :type conversion_factor:measure_with_unit + + :param named_unit_dimensions + :type named_unit_dimensions:dimensional_exponents + ''' + def __init__( self , inherited0__dimensions , name,conversion_factor, ): + named_unit.__init__(self , inherited0__dimensions , ) + self.name = name + self.conversion_factor = conversion_factor + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def conversion_factor(): + def fget( self ): + return self._conversion_factor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument conversion_factor is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._conversion_factor = measure_with_unit(value) + else: + self._conversion_factor = value + return property(**locals()) + + @apply + def named_unit_dimensions(): + def fget( self ): + attribute_eval = derive_dimensional_exponents(self.conversion_factor.self.measure_with_unit.self.unit_component) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument named_unit_dimensions is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY point # +#################### +class point(geometric_representation_item): + '''Entity point definition. + ''' + def __init__( self , inherited0__name , ): + geometric_representation_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY point_on_surface # +#################### +class point_on_surface(point): + '''Entity point_on_surface definition. + + :param basis_surface + :type basis_surface:surface + + :param point_parameter_u + :type point_parameter_u:parameter_value + + :param point_parameter_v + :type point_parameter_v:parameter_value + ''' + def __init__( self , inherited0__name , basis_surface,point_parameter_u,point_parameter_v, ): + point.__init__(self , inherited0__name , ) + self.basis_surface = basis_surface + self.point_parameter_u = point_parameter_u + self.point_parameter_v = point_parameter_v + + @apply + def basis_surface(): + def fget( self ): + return self._basis_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._basis_surface = surface(value) + else: + self._basis_surface = value + return property(**locals()) + + @apply + def point_parameter_u(): + def fget( self ): + return self._point_parameter_u + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument point_parameter_u is mantatory and can not be set to None') + if not check_type(value,parameter_value): + self._point_parameter_u = parameter_value(value) + else: + self._point_parameter_u = value + return property(**locals()) + + @apply + def point_parameter_v(): + def fget( self ): + return self._point_parameter_v + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument point_parameter_v is mantatory and can not be set to None') + if not check_type(value,parameter_value): + self._point_parameter_v = parameter_value(value) + else: + self._point_parameter_v = value + return property(**locals()) + +#################### + # ENTITY product_definition_formation # +#################### +class product_definition_formation(BaseEntityClass): + '''Entity product_definition_formation definition. + + :param id + :type id:identifier + + :param description + :type description:text + + :param of_product + :type of_product:product + ''' + def __init__( self , id,description,of_product, ): + self.id = id + self.description = description + self.of_product = of_product + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def of_product(): + def fget( self ): + return self._of_product + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument of_product is mantatory and can not be set to None') + if not check_type(value,product): + self._of_product = product(value) + else: + self._of_product = value + return property(**locals()) + +#################### + # ENTITY surface_curve_swept_area_solid # +#################### +class surface_curve_swept_area_solid(swept_area_solid): + '''Entity surface_curve_swept_area_solid definition. + + :param directrix + :type directrix:curve + + :param start_param + :type start_param:REAL + + :param end_param + :type end_param:REAL + + :param reference_surface + :type reference_surface:surface + ''' + def __init__( self , inherited0__name , inherited1__swept_area , directrix,start_param,end_param,reference_surface, ): + swept_area_solid.__init__(self , inherited0__name , inherited1__swept_area , ) + self.directrix = directrix + self.start_param = start_param + self.end_param = end_param + self.reference_surface = reference_surface + + @apply + def directrix(): + def fget( self ): + return self._directrix + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directrix is mantatory and can not be set to None') + if not check_type(value,curve): + self._directrix = curve(value) + else: + self._directrix = value + return property(**locals()) + + @apply + def start_param(): + def fget( self ): + return self._start_param + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument start_param is mantatory and can not be set to None') + if not check_type(value,REAL): + self._start_param = REAL(value) + else: + self._start_param = value + return property(**locals()) + + @apply + def end_param(): + def fget( self ): + return self._end_param + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument end_param is mantatory and can not be set to None') + if not check_type(value,REAL): + self._end_param = REAL(value) + else: + self._end_param = value + return property(**locals()) + + @apply + def reference_surface(): + def fget( self ): + return self._reference_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reference_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._reference_surface = surface(value) + else: + self._reference_surface = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not ('AUTOMOTIVE_DESIGN.SURFACE_CURVE' == TYPEOF(self.directrix))) or (self.reference_surface == self.directrix.self.surface_curve.self.basis_surface)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY descriptive_representation_item # +#################### +class descriptive_representation_item(representation_item): + '''Entity descriptive_representation_item definition. + + :param description + :type description:text + ''' + def __init__( self , inherited0__name , description, ): + representation_item.__init__(self , inherited0__name , ) + self.description = description + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY offset_curve_3d # +#################### +class offset_curve_3d(curve): + '''Entity offset_curve_3d definition. + + :param basis_curve + :type basis_curve:curve + + :param distance + :type distance:length_measure + + :param self_intersect + :type self_intersect:LOGICAL + + :param ref_direction + :type ref_direction:direction + ''' + def __init__( self , inherited0__name , basis_curve,distance,self_intersect,ref_direction, ): + curve.__init__(self , inherited0__name , ) + self.basis_curve = basis_curve + self.distance = distance + self.self_intersect = self_intersect + self.ref_direction = ref_direction + + @apply + def basis_curve(): + def fget( self ): + return self._basis_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_curve is mantatory and can not be set to None') + if not check_type(value,curve): + self._basis_curve = curve(value) + else: + self._basis_curve = value + return property(**locals()) + + @apply + def distance(): + def fget( self ): + return self._distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distance is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._distance = length_measure(value) + else: + self._distance = value + return property(**locals()) + + @apply + def self_intersect(): + def fget( self ): + return self._self_intersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument self_intersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._self_intersect = LOGICAL(value) + else: + self._self_intersect = value + return property(**locals()) + + @apply + def ref_direction(): + def fget( self ): + return self._ref_direction + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ref_direction is mantatory and can not be set to None') + if not check_type(value,direction): + self._ref_direction = direction(value) + else: + self._ref_direction = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.basis_curve.self.dim == 3) and (self.ref_direction.self.dim == 3)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY point_style # +#################### +class point_style(founded_item): + '''Entity point_style definition. + + :param name + :type name:label + + :param marker + :type marker:marker_select + + :param marker_size + :type marker_size:size_select + + :param marker_colour + :type marker_colour:colour + ''' + def __init__( self , name,marker,marker_size,marker_colour, ): + founded_item.__init__(self , ) + self.name = name + self.marker = marker + self.marker_size = marker_size + self.marker_colour = marker_colour + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def marker(): + def fget( self ): + return self._marker + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument marker is mantatory and can not be set to None') + if not check_type(value,marker_select): + self._marker = marker_select(value) + else: + self._marker = value + return property(**locals()) + + @apply + def marker_size(): + def fget( self ): + return self._marker_size + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument marker_size is mantatory and can not be set to None') + if not check_type(value,size_select): + self._marker_size = size_select(value) + else: + self._marker_size = value + return property(**locals()) + + @apply + def marker_colour(): + def fget( self ): + return self._marker_colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument marker_colour is mantatory and can not be set to None') + if not check_type(value,colour): + self._marker_colour = colour(value) + else: + self._marker_colour = value + return property(**locals()) + +#################### + # ENTITY approval # +#################### +class approval(BaseEntityClass): + '''Entity approval definition. + + :param status + :type status:approval_status + + :param level + :type level:label + ''' + def __init__( self , status,level, ): + self.status = status + self.level = level + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument status is mantatory and can not be set to None') + if not check_type(value,approval_status): + self._status = approval_status(value) + else: + self._status = value + return property(**locals()) + + @apply + def level(): + def fget( self ): + return self._level + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument level is mantatory and can not be set to None') + if not check_type(value,label): + self._level = label(value) + else: + self._level = value + return property(**locals()) + +#################### + # ENTITY composite_curve # +#################### +class composite_curve(bounded_curve): + '''Entity composite_curve definition. + + :param segments + :type segments:LIST(1,None,'composite_curve_segment', scope = schema_scope) + + :param self_intersect + :type self_intersect:LOGICAL + + :param n_segments + :type n_segments:INTEGER + + :param closed_curve + :type closed_curve:LOGICAL + ''' + def __init__( self , inherited0__name , segments,self_intersect, ): + bounded_curve.__init__(self , inherited0__name , ) + self.segments = segments + self.self_intersect = self_intersect + + @apply + def segments(): + def fget( self ): + return self._segments + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument segments is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'composite_curve_segment', scope = schema_scope)): + self._segments = LIST(value) + else: + self._segments = value + return property(**locals()) + + @apply + def self_intersect(): + def fget( self ): + return self._self_intersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument self_intersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._self_intersect = LOGICAL(value) + else: + self._self_intersect = value + return property(**locals()) + + @apply + def n_segments(): + def fget( self ): + attribute_eval = SIZEOF(self.segments) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument n_segments is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def closed_curve(): + def fget( self ): + attribute_eval = (self.segments[self.n_segments].self.transition != discontinuous) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument closed_curve is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((( not self.closed_curve) and (SIZEOF(None) == 1)) or (self.closed_curve and (SIZEOF(None) == 0))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY composite_curve_on_surface # +#################### +class composite_curve_on_surface(composite_curve): + '''Entity composite_curve_on_surface definition. + + :param basis_surface + :type basis_surface:SET(0,2,'surface', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__segments , inherited2__self_intersect , ): + composite_curve.__init__(self , inherited0__name , inherited1__segments , inherited2__self_intersect , ) + + @apply + def basis_surface(): + def fget( self ): + attribute_eval = get_basis_surface(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument basis_surface is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.basis_surface) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = constraints_composite_curve_on_surface(self) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY boundary_curve # +#################### +class boundary_curve(composite_curve_on_surface): + '''Entity boundary_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__segments , inherited2__self_intersect , ): + composite_curve_on_surface.__init__(self , inherited0__name , inherited1__segments , inherited2__self_intersect , ) + def wr1(self): + eval_wr1_wr = self.self.composite_curve.self.closed_curve + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY event_occurrence_role # +#################### +class event_occurrence_role(BaseEntityClass): + '''Entity event_occurrence_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY representation_context # +#################### +class representation_context(BaseEntityClass): + '''Entity representation_context definition. + + :param context_identifier + :type context_identifier:identifier + + :param context_type + :type context_type:text + + :param representations_in_context + :type representations_in_context:SET(1,None,'representation', scope = schema_scope) + ''' + def __init__( self , context_identifier,context_type, ): + self.context_identifier = context_identifier + self.context_type = context_type + + @apply + def context_identifier(): + def fget( self ): + return self._context_identifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument context_identifier is mantatory and can not be set to None') + if not check_type(value,identifier): + self._context_identifier = identifier(value) + else: + self._context_identifier = value + return property(**locals()) + + @apply + def context_type(): + def fget( self ): + return self._context_type + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument context_type is mantatory and can not be set to None') + if not check_type(value,text): + self._context_type = text(value) + else: + self._context_type = value + return property(**locals()) + + @apply + def representations_in_context(): + def fget( self ): + return self._representations_in_context + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument representations_in_context is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY geometric_representation_context # +#################### +class geometric_representation_context(representation_context): + '''Entity geometric_representation_context definition. + + :param coordinate_space_dimension + :type coordinate_space_dimension:dimension_count + ''' + def __init__( self , inherited0__context_identifier , inherited1__context_type , coordinate_space_dimension, ): + representation_context.__init__(self , inherited0__context_identifier , inherited1__context_type , ) + self.coordinate_space_dimension = coordinate_space_dimension + + @apply + def coordinate_space_dimension(): + def fget( self ): + return self._coordinate_space_dimension + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordinate_space_dimension is mantatory and can not be set to None') + if not check_type(value,dimension_count): + self._coordinate_space_dimension = dimension_count(value) + else: + self._coordinate_space_dimension = value + return property(**locals()) + +#################### + # ENTITY string_defined_function # +#################### +class string_defined_function(defined_function,string_expression): + '''Entity string_defined_function definition. + ''' + def __init__( self , ): + defined_function.__init__(self , ) + string_expression.__init__(self , ) + +#################### + # ENTITY date_assignment # +#################### +class date_assignment(BaseEntityClass): + '''Entity date_assignment definition. + + :param assigned_date + :type assigned_date:date + + :param role + :type role:date_role + ''' + def __init__( self , assigned_date,role, ): + self.assigned_date = assigned_date + self.role = role + + @apply + def assigned_date(): + def fget( self ): + return self._assigned_date + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_date is mantatory and can not be set to None') + if not check_type(value,date): + self._assigned_date = date(value) + else: + self._assigned_date = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,date_role): + self._role = date_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY applied_date_assignment # +#################### +class applied_date_assignment(date_assignment): + '''Entity applied_date_assignment definition. + + :param items + :type items:SET(1,None,'date_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_date , inherited1__role , items, ): + date_assignment.__init__(self , inherited0__assigned_date , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'date_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (self.self.role.self.name == 'actual end')) or item_correlation(self.self.items,['ACTION','ORGANIZATIONAL_PROJECT','EFFECTIVITY'])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY celsius_temperature_measure_with_unit # +#################### +class celsius_temperature_measure_with_unit(measure_with_unit): + '''Entity celsius_temperature_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.THERMODYNAMIC_TEMPERATURE_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY draughting_annotation_occurrence # +#################### +class draughting_annotation_occurrence(annotation_occurrence): + '''Entity draughting_annotation_occurrence definition. + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , ): + annotation_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , ) + def wr1(self): + eval_wr1_wr = (( not ('AUTOMOTIVE_DESIGN.ANNOTATION_CURVE_OCCURRENCE' == TYPEOF(self))) or (SIZEOF(None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not ('AUTOMOTIVE_DESIGN.ANNOTATION_FILL_AREA_OCCURRENCE' == TYPEOF(self))) or (SIZEOF(None) == 0)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not ('AUTOMOTIVE_DESIGN.ANNOTATION_FILL_AREA_OCCURRENCE' == TYPEOF(self))) or (SIZEOF(None) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not ('AUTOMOTIVE_DESIGN.ANNOTATION_SYMBOL_OCCURRENCE' == TYPEOF(self))) or (SIZEOF(None) == 0)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (( not (('AUTOMOTIVE_DESIGN.ANNOTATION_SYMBOL_OCCURRENCE' == TYPEOF(self)) and ('AUTOMOTIVE_DESIGN.ANNOTATION_SYMBOL' == TYPEOF(self.self.item)))) or (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'DRAUGHTING_SYMBOL_REPRESENTATION','AUTOMOTIVE_DESIGN.' + 'DRAUGHTING_SUBFIGURE_REPRESENTATION'] * TYPEOF(self.self.item.self.mapped_item.self.mapping_source.self.mapped_representation)) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (( not ('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self))) or (SIZEOF(None) == 0)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self)) or (SIZEOF(TYPEOF(self.self.item) * ['AUTOMOTIVE_DESIGN.COMPOSITE_TEXT','AUTOMOTIVE_DESIGN.TEXT_LITERAL']) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (( not (('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self)) and ('AUTOMOTIVE_DESIGN.COMPOSITE_TEXT' == TYPEOF(self.self.item)))) or (SIZEOF(None) == 0)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (( not (('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self)) and ('AUTOMOTIVE_DESIGN.TEXT_LITERAL' == TYPEOF(self.self.item)))) or (self.self.item.self.text_literal.self.alignment == ['baseline left','baseline centre','baseline right'])) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (( not (('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self)) and ('AUTOMOTIVE_DESIGN.COMPOSITE_TEXT' == TYPEOF(self.self.item)))) or (SIZEOF(None) == 0)) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (( not (('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self)) and ('AUTOMOTIVE_DESIGN.COMPOSITE_TEXT' == TYPEOF(self.self.item)))) or check_text_alignment(self.self.item)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (( not (('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self)) and ('AUTOMOTIVE_DESIGN.COMPOSITE_TEXT' == TYPEOF(self.self.item)))) or check_text_font(self.self.item)) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = (( not (('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self)) and ('AUTOMOTIVE_DESIGN.COMPOSITE_TEXT' == TYPEOF(self.self.item)))) or (SIZEOF(None) == 0)) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + def wr14(self): + eval_wr14_wr = (( not (('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self)) and ('AUTOMOTIVE_DESIGN.TEXT_LITERAL_WITH_ASSOCIATED_CURVES' == TYPEOF(self.self.item)))) or (SIZEOF(None) == 0)) + if not eval_wr14_wr: + raise AssertionError('Rule wr14 violated') + else: + return eval_wr14_wr + + def wr15(self): + eval_wr15_wr = (( not (('AUTOMOTIVE_DESIGN.ANNOTATION_TEXT_OCCURRENCE' == TYPEOF(self)) and ('AUTOMOTIVE_DESIGN.COMPOSITE_TEXT_WITH_ASSOCIATED_CURVES' == TYPEOF(self.self.item)))) or (SIZEOF(None) == 0)) + if not eval_wr15_wr: + raise AssertionError('Rule wr15 violated') + else: + return eval_wr15_wr + + def wr16(self): + eval_wr16_wr = (SIZEOF(None) == 0) + if not eval_wr16_wr: + raise AssertionError('Rule wr16 violated') + else: + return eval_wr16_wr + + def wr17(self): + eval_wr17_wr = (SIZEOF(None) == 0) + if not eval_wr17_wr: + raise AssertionError('Rule wr17 violated') + else: + return eval_wr17_wr + + def wr18(self): + eval_wr18_wr = (SIZEOF(None) == 0) + if not eval_wr18_wr: + raise AssertionError('Rule wr18 violated') + else: + return eval_wr18_wr + + def wr19(self): + eval_wr19_wr = (SIZEOF(None) == 0) + if not eval_wr19_wr: + raise AssertionError('Rule wr19 violated') + else: + return eval_wr19_wr + + def wr20(self): + eval_wr20_wr = (SIZEOF(None) == 0) + if not eval_wr20_wr: + raise AssertionError('Rule wr20 violated') + else: + return eval_wr20_wr + + +#################### + # ENTITY path_feature_component # +#################### +class path_feature_component(shape_aspect): + '''Entity path_feature_component definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.description == ['partial circular','complete circular','linear','complex']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'partial circular') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'partial circular') or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((self.self.description != 'partial circular') or (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((self.self.description != 'complete circular') or (SIZEOF(None) == 1)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = ((self.self.description != 'complete circular') or (SIZEOF(None) == 1)) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = ((self.self.description != 'linear') or (SIZEOF(None) == 1)) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = ((self.self.description != 'linear') or (SIZEOF(None) == 1)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = ((self.self.description != 'complex') or ((SIZEOF(None) == 1) and (SIZEOF(None) == 1))) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = ((self.self.description != 'complex') or (SIZEOF(None) == 1)) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + +#################### + # ENTITY derived_unit # +#################### +class derived_unit(BaseEntityClass): + '''Entity derived_unit definition. + + :param elements + :type elements:SET(1,None,'derived_unit_element', scope = schema_scope) + + :param name + :type name:label + ''' + def __init__( self , elements, ): + self.elements = elements + + @apply + def elements(): + def fget( self ): + return self._elements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument elements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'derived_unit_element', scope = schema_scope)): + self._elements = SET(value) + else: + self._elements = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((SIZEOF(self.elements) > 1) or ((SIZEOF(self.elements) == 1) and (self.elements[1].self.exponent != 1))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY derived_unit_variable # +#################### +class derived_unit_variable(derived_unit,variable_semantics): + '''Entity derived_unit_variable definition. + + :param associated_variable_environment + :type associated_variable_environment:environment + ''' + def __init__( self , inherited0__elements , ): + derived_unit.__init__(self , inherited0__elements , ) + variable_semantics.__init__(self , ) + + @apply + def associated_variable_environment(): + def fget( self ): + return self._associated_variable_environment + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument associated_variable_environment is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY log_function # +#################### +class log_function(unary_function_call): + '''Entity log_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY compound_representation_item # +#################### +class compound_representation_item(representation_item): + '''Entity compound_representation_item definition. + + :param item_element + :type item_element:compound_item_definition + ''' + def __init__( self , inherited0__name , item_element, ): + representation_item.__init__(self , inherited0__name , ) + self.item_element = item_element + + @apply + def item_element(): + def fget( self ): + return self._item_element + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_element is mantatory and can not be set to None') + if not check_type(value,compound_item_definition): + self._item_element = compound_item_definition(value) + else: + self._item_element = value + return property(**locals()) + +#################### + # ENTITY value_range # +#################### +class value_range(compound_representation_item): + '''Entity value_range definition. + ''' + def __init__( self , inherited0__name , inherited1__item_element , ): + compound_representation_item.__init__(self , inherited0__name , inherited1__item_element , ) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.' + 'SET_REPRESENTATION_ITEM') == TYPEOF(self.item_element)) and value_range_wr1(self.item_element)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = value_range_wr2(self.item_element) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = value_range_wr3(self.item_element) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY boss # +#################### +class boss(feature_definition): + '''Entity boss definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (self.self.description == ['circular','rectangular','complex']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((self.self.description != 'circular') or (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((self.self.description != 'complex') or (SIZEOF(None) == 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.description != 'rectangular') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) == 0)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 1) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (( not (self.self.description == ['rectangular','complex'])) or (SIZEOF(None) <= 1)) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = ((self.self.description != 'circular') or (SIZEOF(None) <= 1)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY surface_style_reflectance_ambient # +#################### +class surface_style_reflectance_ambient(BaseEntityClass): + '''Entity surface_style_reflectance_ambient definition. + + :param ambient_reflectance + :type ambient_reflectance:REAL + ''' + def __init__( self , ambient_reflectance, ): + self.ambient_reflectance = ambient_reflectance + + @apply + def ambient_reflectance(): + def fget( self ): + return self._ambient_reflectance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ambient_reflectance is mantatory and can not be set to None') + if not check_type(value,REAL): + self._ambient_reflectance = REAL(value) + else: + self._ambient_reflectance = value + return property(**locals()) + +#################### + # ENTITY surface_style_reflectance_ambient_diffuse # +#################### +class surface_style_reflectance_ambient_diffuse(surface_style_reflectance_ambient): + '''Entity surface_style_reflectance_ambient_diffuse definition. + + :param diffuse_reflectance + :type diffuse_reflectance:REAL + ''' + def __init__( self , inherited0__ambient_reflectance , diffuse_reflectance, ): + surface_style_reflectance_ambient.__init__(self , inherited0__ambient_reflectance , ) + self.diffuse_reflectance = diffuse_reflectance + + @apply + def diffuse_reflectance(): + def fget( self ): + return self._diffuse_reflectance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument diffuse_reflectance is mantatory and can not be set to None') + if not check_type(value,REAL): + self._diffuse_reflectance = REAL(value) + else: + self._diffuse_reflectance = value + return property(**locals()) + +#################### + # ENTITY action_status # +#################### +class action_status(BaseEntityClass): + '''Entity action_status definition. + + :param status + :type status:label + + :param assigned_action + :type assigned_action:executed_action + ''' + def __init__( self , status,assigned_action, ): + self.status = status + self.assigned_action = assigned_action + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument status is mantatory and can not be set to None') + if not check_type(value,label): + self._status = label(value) + else: + self._status = value + return property(**locals()) + + @apply + def assigned_action(): + def fget( self ): + return self._assigned_action + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_action is mantatory and can not be set to None') + if not check_type(value,executed_action): + self._assigned_action = executed_action(value) + else: + self._assigned_action = value + return property(**locals()) + +#################### + # ENTITY draughting_callout_relationship # +#################### +class draughting_callout_relationship(BaseEntityClass): + '''Entity draughting_callout_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_draughting_callout + :type relating_draughting_callout:draughting_callout + + :param related_draughting_callout + :type related_draughting_callout:draughting_callout + ''' + def __init__( self , name,description,relating_draughting_callout,related_draughting_callout, ): + self.name = name + self.description = description + self.relating_draughting_callout = relating_draughting_callout + self.related_draughting_callout = related_draughting_callout + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def relating_draughting_callout(): + def fget( self ): + return self._relating_draughting_callout + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_draughting_callout is mantatory and can not be set to None') + if not check_type(value,draughting_callout): + self._relating_draughting_callout = draughting_callout(value) + else: + self._relating_draughting_callout = value + return property(**locals()) + + @apply + def related_draughting_callout(): + def fget( self ): + return self._related_draughting_callout + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_draughting_callout is mantatory and can not be set to None') + if not check_type(value,draughting_callout): + self._related_draughting_callout = draughting_callout(value) + else: + self._related_draughting_callout = value + return property(**locals()) + +#################### + # ENTITY dimension_pair # +#################### +class dimension_pair(draughting_callout_relationship): + '''Entity dimension_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_draughting_callout , inherited3__related_draughting_callout , ): + draughting_callout_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_draughting_callout , inherited3__related_draughting_callout , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['chained','parallel']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(TYPEOF(self.self.relating_draughting_callout) * ['AUTOMOTIVE_DESIGN.ANGULAR_DIMENSION','AUTOMOTIVE_DESIGN.CURVE_DIMENSION','AUTOMOTIVE_DESIGN.DIAMETER_DIMENSION','AUTOMOTIVE_DESIGN.LINEAR_DIMENSION','AUTOMOTIVE_DESIGN.ORDINATE_DIMENSION','AUTOMOTIVE_DESIGN.RADIUS_DIMENSION']) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(TYPEOF(self.self.related_draughting_callout) * ['AUTOMOTIVE_DESIGN.ANGULAR_DIMENSION','AUTOMOTIVE_DESIGN.CURVE_DIMENSION','AUTOMOTIVE_DESIGN.DIAMETER_DIMENSION','AUTOMOTIVE_DESIGN.LINEAR_DIMENSION','AUTOMOTIVE_DESIGN.ORDINATE_DIMENSION','AUTOMOTIVE_DESIGN.RADIUS_DIMENSION']) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY draughting_title # +#################### +class draughting_title(BaseEntityClass): + '''Entity draughting_title definition. + + :param items + :type items:SET(1,None,'draughting_titled_item', scope = schema_scope) + + :param language + :type language:label + + :param contents + :type contents:text + ''' + def __init__( self , items,language,contents, ): + self.items = items + self.language = language + self.contents = contents + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'draughting_titled_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + + @apply + def language(): + def fget( self ): + return self._language + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument language is mantatory and can not be set to None') + if not check_type(value,label): + self._language = label(value) + else: + self._language = value + return property(**locals()) + + @apply + def contents(): + def fget( self ): + return self._contents + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument contents is mantatory and can not be set to None') + if not check_type(value,text): + self._contents = text(value) + else: + self._contents = value + return property(**locals()) + +#################### + # ENTITY application_context # +#################### +class application_context(BaseEntityClass): + '''Entity application_context definition. + + :param application + :type application:label + + :param description + :type description:text + + :param id + :type id:identifier + + :param context_elements + :type context_elements:SET(1,None,'application_context_element', scope = schema_scope) + ''' + def __init__( self , application, ): + self.application = application + + @apply + def application(): + def fget( self ): + return self._application + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument application is mantatory and can not be set to None') + if not check_type(value,label): + self._application = label(value) + else: + self._application = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def id(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument id is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def context_elements(): + def fget( self ): + return self._context_elements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument context_elements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY presented_item # +#################### +class presented_item(BaseEntityClass): + '''Entity presented_item definition. + ''' + # This class does not define any attribute. + pass + +#################### + # ENTITY applied_presented_item # +#################### +class applied_presented_item(presented_item): + '''Entity applied_presented_item definition. + + :param items + :type items:SET(1,None,'presented_item_select', scope = schema_scope) + ''' + def __init__( self , items, ): + presented_item.__init__(self , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'presented_item_select', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY date_and_time # +#################### +class date_and_time(BaseEntityClass): + '''Entity date_and_time definition. + + :param date_component + :type date_component:date + + :param time_component + :type time_component:local_time + ''' + def __init__( self , date_component,time_component, ): + self.date_component = date_component + self.time_component = time_component + + @apply + def date_component(): + def fget( self ): + return self._date_component + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument date_component is mantatory and can not be set to None') + if not check_type(value,date): + self._date_component = date(value) + else: + self._date_component = value + return property(**locals()) + + @apply + def time_component(): + def fget( self ): + return self._time_component + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument time_component is mantatory and can not be set to None') + if not check_type(value,local_time): + self._time_component = local_time(value) + else: + self._time_component = value + return property(**locals()) + +#################### + # ENTITY feature_component_relationship # +#################### +class feature_component_relationship(shape_aspect_relationship): + '''Entity feature_component_relationship definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ): + shape_aspect_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.' + 'TRANSITION_FEATURE') == TYPEOF(self.self.related_shape_aspect)) or (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'FEATURE_DEFINITION','AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION'] * TYPEOF(self.self.related_shape_aspect.self.of_shape.self.definition)) == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY pattern_omit_membership # +#################### +class pattern_omit_membership(feature_component_relationship): + '''Entity pattern_omit_membership definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ): + feature_component_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'CIRCULAR_PATTERN','AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN'] * TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition)) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) >= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(get_property_definition_representations(self.self.related_shape_aspect.self.of_shape.self.definition)) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'CIRCULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'CIRCULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + +#################### + # ENTITY derived_shape_aspect # +#################### +class derived_shape_aspect(shape_aspect): + '''Entity derived_shape_aspect definition. + + :param deriving_relationships + :type deriving_relationships:SET(1,None,'shape_aspect_relationship', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + + @apply + def deriving_relationships(): + def fget( self ): + return self._deriving_relationships + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument deriving_relationships is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY apex # +#################### +class apex(derived_shape_aspect): + '''Entity apex definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + derived_shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + +#################### + # ENTITY tolerance_value # +#################### +class tolerance_value(BaseEntityClass): + '''Entity tolerance_value definition. + + :param lower_bound + :type lower_bound:measure_with_unit + + :param upper_bound + :type upper_bound:measure_with_unit + ''' + def __init__( self , lower_bound,upper_bound, ): + self.lower_bound = lower_bound + self.upper_bound = upper_bound + + @apply + def lower_bound(): + def fget( self ): + return self._lower_bound + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_bound is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._lower_bound = measure_with_unit(value) + else: + self._lower_bound = value + return property(**locals()) + + @apply + def upper_bound(): + def fget( self ): + return self._upper_bound + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_bound is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._upper_bound = measure_with_unit(value) + else: + self._upper_bound = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.upper_bound.self.measure_with_unit.self.value_component > self.lower_bound.self.measure_with_unit.self.value_component) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.upper_bound.self.measure_with_unit.self.unit_component == self.lower_bound.self.measure_with_unit.self.unit_component) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY approval_date_time # +#################### +class approval_date_time(BaseEntityClass): + '''Entity approval_date_time definition. + + :param date_time + :type date_time:date_time_select + + :param dated_approval + :type dated_approval:approval + + :param role + :type role:object_role + ''' + def __init__( self , date_time,dated_approval, ): + self.date_time = date_time + self.dated_approval = dated_approval + + @apply + def date_time(): + def fget( self ): + return self._date_time + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument date_time is mantatory and can not be set to None') + if not check_type(value,date_time_select): + self._date_time = date_time_select(value) + else: + self._date_time = value + return property(**locals()) + + @apply + def dated_approval(): + def fget( self ): + return self._dated_approval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dated_approval is mantatory and can not be set to None') + if not check_type(value,approval): + self._dated_approval = approval(value) + else: + self._dated_approval = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY approval_role # +#################### +class approval_role(BaseEntityClass): + '''Entity approval_role definition. + + :param role + :type role:label + + :param description + :type description:text + ''' + def __init__( self , role, ): + self.role = role + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,label): + self._role = label(value) + else: + self._role = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY application_context_element # +#################### +class application_context_element(BaseEntityClass): + '''Entity application_context_element definition. + + :param name + :type name:label + + :param frame_of_reference + :type frame_of_reference:application_context + ''' + def __init__( self , name,frame_of_reference, ): + self.name = name + self.frame_of_reference = frame_of_reference + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def frame_of_reference(): + def fget( self ): + return self._frame_of_reference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument frame_of_reference is mantatory and can not be set to None') + if not check_type(value,application_context): + self._frame_of_reference = application_context(value) + else: + self._frame_of_reference = value + return property(**locals()) + +#################### + # ENTITY product_context # +#################### +class product_context(application_context_element): + '''Entity product_context definition. + + :param discipline_type + :type discipline_type:label + ''' + def __init__( self , inherited0__name , inherited1__frame_of_reference , discipline_type, ): + application_context_element.__init__(self , inherited0__name , inherited1__frame_of_reference , ) + self.discipline_type = discipline_type + + @apply + def discipline_type(): + def fget( self ): + return self._discipline_type + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument discipline_type is mantatory and can not be set to None') + if not check_type(value,label): + self._discipline_type = label(value) + else: + self._discipline_type = value + return property(**locals()) + +#################### + # ENTITY elementary_surface # +#################### +class elementary_surface(surface): + '''Entity elementary_surface definition. + + :param position + :type position:axis2_placement_3d + ''' + def __init__( self , inherited0__name , position, ): + surface.__init__(self , inherited0__name , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,axis2_placement_3d): + self._position = axis2_placement_3d(value) + else: + self._position = value + return property(**locals()) + +#################### + # ENTITY spherical_surface # +#################### +class spherical_surface(elementary_surface): + '''Entity spherical_surface definition. + + :param radius + :type radius:positive_length_measure + ''' + def __init__( self , inherited0__name , inherited1__position , radius, ): + elementary_surface.__init__(self , inherited0__name , inherited1__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._radius = positive_length_measure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY annotation_curve_occurrence # +#################### +class annotation_curve_occurrence(annotation_occurrence): + '''Entity annotation_curve_occurrence definition. + + :param styled_item_item + :type styled_item_item:curve + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , styled_item_item, ): + annotation_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , ) + self.styled_item_item = styled_item_item + + @apply + def styled_item_item(): + def fget( self ): + return self._styled_item_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styled_item_item is mantatory and can not be set to None') + if not check_type(value,curve): + self._styled_item_item = curve(value) + else: + self._styled_item_item = value + return property(**locals()) + +#################### + # ENTITY projection_curve # +#################### +class projection_curve(annotation_curve_occurrence): + '''Entity projection_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , ): + annotation_curve_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , ) + +#################### + # ENTITY application_protocol_definition # +#################### +class application_protocol_definition(BaseEntityClass): + '''Entity application_protocol_definition definition. + + :param status + :type status:label + + :param application_interpreted_model_schema_name + :type application_interpreted_model_schema_name:label + + :param application_protocol_year + :type application_protocol_year:year_number + + :param application + :type application:application_context + ''' + def __init__( self , status,application_interpreted_model_schema_name,application_protocol_year,application, ): + self.status = status + self.application_interpreted_model_schema_name = application_interpreted_model_schema_name + self.application_protocol_year = application_protocol_year + self.application = application + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument status is mantatory and can not be set to None') + if not check_type(value,label): + self._status = label(value) + else: + self._status = value + return property(**locals()) + + @apply + def application_interpreted_model_schema_name(): + def fget( self ): + return self._application_interpreted_model_schema_name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument application_interpreted_model_schema_name is mantatory and can not be set to None') + if not check_type(value,label): + self._application_interpreted_model_schema_name = label(value) + else: + self._application_interpreted_model_schema_name = value + return property(**locals()) + + @apply + def application_protocol_year(): + def fget( self ): + return self._application_protocol_year + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument application_protocol_year is mantatory and can not be set to None') + if not check_type(value,year_number): + self._application_protocol_year = year_number(value) + else: + self._application_protocol_year = value + return property(**locals()) + + @apply + def application(): + def fget( self ): + return self._application + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument application is mantatory and can not be set to None') + if not check_type(value,application_context): + self._application = application_context(value) + else: + self._application = value + return property(**locals()) + +#################### + # ENTITY dimensional_size # +#################### +class dimensional_size(BaseEntityClass): + '''Entity dimensional_size definition. + + :param applies_to + :type applies_to:shape_aspect + + :param name + :type name:label + ''' + def __init__( self , applies_to,name, ): + self.applies_to = applies_to + self.name = name + + @apply + def applies_to(): + def fget( self ): + return self._applies_to + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applies_to is mantatory and can not be set to None') + if not check_type(value,shape_aspect): + self._applies_to = shape_aspect(value) + else: + self._applies_to = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.applies_to.self.product_definitional == TRUE) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY externally_defined_dimension_definition # +#################### +class externally_defined_dimension_definition(dimensional_size,externally_defined_item): + '''Entity externally_defined_dimension_definition definition. + ''' + def __init__( self , inherited0__applies_to , inherited1__name , inherited2__item_id , inherited3__source , ): + dimensional_size.__init__(self , inherited0__applies_to , inherited1__name , ) + externally_defined_item.__init__(self , inherited2__item_id , inherited3__source , ) + def wr1(self): + eval_wr1_wr = ((self.self.externally_defined_item.self.item_id == 'external size dimension') and (self.self.externally_defined_item.self.source.self.source_id == 'external size dimension specification')) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (1 >= SIZEOF(None)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY swept_disk_solid # +#################### +class swept_disk_solid(solid_model): + '''Entity swept_disk_solid definition. + + :param directrix + :type directrix:curve + + :param radius + :type radius:positive_length_measure + + :param inner_radius + :type inner_radius:positive_length_measure + + :param start_param + :type start_param:REAL + + :param end_param + :type end_param:REAL + ''' + def __init__( self , inherited0__name , directrix,radius,inner_radius,start_param,end_param, ): + solid_model.__init__(self , inherited0__name , ) + self.directrix = directrix + self.radius = radius + self.inner_radius = inner_radius + self.start_param = start_param + self.end_param = end_param + + @apply + def directrix(): + def fget( self ): + return self._directrix + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directrix is mantatory and can not be set to None') + if not check_type(value,curve): + self._directrix = curve(value) + else: + self._directrix = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._radius = positive_length_measure(value) + else: + self._radius = value + return property(**locals()) + + @apply + def inner_radius(): + def fget( self ): + return self._inner_radius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,positive_length_measure): + self._inner_radius = positive_length_measure(value) + else: + self._inner_radius = value + else: + self._inner_radius = value + return property(**locals()) + + @apply + def start_param(): + def fget( self ): + return self._start_param + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument start_param is mantatory and can not be set to None') + if not check_type(value,REAL): + self._start_param = REAL(value) + else: + self._start_param = value + return property(**locals()) + + @apply + def end_param(): + def fget( self ): + return self._end_param + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument end_param is mantatory and can not be set to None') + if not check_type(value,REAL): + self._end_param = REAL(value) + else: + self._end_param = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.directrix.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not EXISTS(self.inner_radius)) or (self.radius > self.inner_radius)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY dimension_callout_relationship # +#################### +class dimension_callout_relationship(draughting_callout_relationship): + '''Entity dimension_callout_relationship definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_draughting_callout , inherited3__related_draughting_callout , ): + draughting_callout_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_draughting_callout , inherited3__related_draughting_callout , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['primary','secondary']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(TYPEOF(self.self.relating_draughting_callout) * ['AUTOMOTIVE_DESIGN.ANGULAR_DIMENSION','AUTOMOTIVE_DESIGN.CURVE_DIMENSION','AUTOMOTIVE_DESIGN.DIAMETER_DIMENSION','AUTOMOTIVE_DESIGN.LEADER_DIRECTED_DIMENSION','AUTOMOTIVE_DESIGN.LINEAR_DIMENSION','AUTOMOTIVE_DESIGN.ORDINATE_DIMENSION','AUTOMOTIVE_DESIGN.RADIUS_DIMENSION']) >= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(TYPEOF(self.self.related_draughting_callout) * ['AUTOMOTIVE_DESIGN.DIMENSION_CURVE_DIRECTED_CALLOUT','AUTOMOTIVE_DESIGN.PROJECTION_DIRECTED_CALLOUT','AUTOMOTIVE_DESIGN.LEADER_DIRECTED_CALLOUT']) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.related_draughting_callout.self.contents * self.self.relating_draughting_callout.self.contents) == self.self.related_draughting_callout.self.contents) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY process_property_association # +#################### +class process_property_association(BaseEntityClass): + '''Entity process_property_association definition. + + :param name + :type name:label + + :param description + :type description:text + + :param process + :type process:property_process + + :param property_or_shape + :type property_or_shape:property_or_shape_select + ''' + def __init__( self , name,description,process,property_or_shape, ): + self.name = name + self.description = description + self.process = process + self.property_or_shape = property_or_shape + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def process(): + def fget( self ): + return self._process + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument process is mantatory and can not be set to None') + if not check_type(value,property_process): + self._process = property_process(value) + else: + self._process = value + return property(**locals()) + + @apply + def property_or_shape(): + def fget( self ): + return self._property_or_shape + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument property_or_shape is mantatory and can not be set to None') + if not check_type(value,property_or_shape_select): + self._property_or_shape = property_or_shape_select(value) + else: + self._property_or_shape = value + return property(**locals()) + +#################### + # ENTITY specified_higher_usage_occurrence # +#################### +class specified_higher_usage_occurrence(assembly_component_usage): + '''Entity specified_higher_usage_occurrence definition. + + :param upper_usage + :type upper_usage:assembly_component_usage + + :param next_usage + :type next_usage:next_assembly_usage_occurrence + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , inherited5__reference_designator , upper_usage,next_usage, ): + assembly_component_usage.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , inherited5__reference_designator , ) + self.upper_usage = upper_usage + self.next_usage = next_usage + + @apply + def upper_usage(): + def fget( self ): + return self._upper_usage + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_usage is mantatory and can not be set to None') + if not check_type(value,assembly_component_usage): + self._upper_usage = assembly_component_usage(value) + else: + self._upper_usage = value + return property(**locals()) + + @apply + def next_usage(): + def fget( self ): + return self._next_usage + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument next_usage is mantatory and can not be set to None') + if not check_type(value,next_assembly_usage_occurrence): + self._next_usage = next_assembly_usage_occurrence(value) + else: + self._next_usage = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self != self.upper_usage) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.product_definition_relationship.self.relating_product_definition == self.upper_usage.self.relating_product_definition) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.self.product_definition_relationship.self.related_product_definition == self.next_usage.self.related_product_definition) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.upper_usage.self.related_product_definition == self.next_usage.self.relating_product_definition) or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.NEXT_ASSEMBLY_USAGE_OCCURRENCE','AUTOMOTIVE_DESIGN.SPECIFIED_HIGHER_USAGE_OCCURRENCE'] * TYPEOF(self.upper_usage)) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY dimensional_location_with_path # +#################### +class dimensional_location_with_path(dimensional_location): + '''Entity dimensional_location_with_path definition. + + :param path + :type path:shape_aspect + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , path, ): + dimensional_location.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + self.path = path + + @apply + def path(): + def fget( self ): + return self._path + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument path is mantatory and can not be set to None') + if not check_type(value,shape_aspect): + self._path = shape_aspect(value) + else: + self._path = value + return property(**locals()) + +#################### + # ENTITY feature_in_panel # +#################### +class feature_in_panel(feature_definition): + '''Entity feature_in_panel definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (self.self.description == ['pocket','boss','stairstep']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) <= 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == SIZEOF(None)) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) == SIZEOF(None)) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) == 0)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = ((SIZEOF(None) == 0) or (SIZEOF(None) == 1)) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + +#################### + # ENTITY pattern_offset_membership # +#################### +class pattern_offset_membership(feature_component_relationship): + '''Entity pattern_offset_membership definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ): + feature_component_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'CIRCULAR_PATTERN','AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN'] * TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition)) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) >= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(get_property_definition_representations(self.self.related_shape_aspect.self.of_shape.self.definition)) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'CIRCULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'CIRCULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'CIRCULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_PATTERN') == TYPEOF(self.self.relating_shape_aspect.self.of_shape.self.definition))) or (SIZEOF(None) == 1)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY product_definition_formation_with_specified_source # +#################### +class product_definition_formation_with_specified_source(product_definition_formation): + '''Entity product_definition_formation_with_specified_source definition. + + :param make_or_buy + :type make_or_buy:source + ''' + def __init__( self , inherited0__id , inherited1__description , inherited2__of_product , make_or_buy, ): + product_definition_formation.__init__(self , inherited0__id , inherited1__description , inherited2__of_product , ) + self.make_or_buy = make_or_buy + + @apply + def make_or_buy(): + def fget( self ): + return self._make_or_buy + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument make_or_buy is mantatory and can not be set to None') + if not check_type(value,source): + self._make_or_buy = source(value) + else: + self._make_or_buy = value + return property(**locals()) + +#################### + # ENTITY surface_style_transparent # +#################### +class surface_style_transparent(BaseEntityClass): + '''Entity surface_style_transparent definition. + + :param transparency + :type transparency:REAL + ''' + def __init__( self , transparency, ): + self.transparency = transparency + + @apply + def transparency(): + def fget( self ): + return self._transparency + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transparency is mantatory and can not be set to None') + if not check_type(value,REAL): + self._transparency = REAL(value) + else: + self._transparency = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((0 <= self.transparency) and (self.transparency <= 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY amount_of_substance_measure_with_unit # +#################### +class amount_of_substance_measure_with_unit(measure_with_unit): + '''Entity amount_of_substance_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.AMOUNT_OF_SUBSTANCE_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY cylindrical_pair_range # +#################### +class cylindrical_pair_range(simple_pair_range): + '''Entity cylindrical_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:cylindrical_pair + + :param lower_limit_actual_translation + :type lower_limit_actual_translation:translational_range_measure + + :param upper_limit_actual_translation + :type upper_limit_actual_translation:translational_range_measure + + :param lower_limit_actual_rotation + :type lower_limit_actual_rotation:rotational_range_measure + + :param upper_limit_actual_rotation + :type upper_limit_actual_rotation:rotational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,lower_limit_actual_translation,upper_limit_actual_translation,lower_limit_actual_rotation,upper_limit_actual_rotation, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.lower_limit_actual_translation = lower_limit_actual_translation + self.upper_limit_actual_translation = upper_limit_actual_translation + self.lower_limit_actual_rotation = lower_limit_actual_rotation + self.upper_limit_actual_rotation = upper_limit_actual_rotation + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,cylindrical_pair): + self._simple_pair_range_applies_to_pair = cylindrical_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def lower_limit_actual_translation(): + def fget( self ): + return self._lower_limit_actual_translation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_translation is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._lower_limit_actual_translation = translational_range_measure(value) + else: + self._lower_limit_actual_translation = value + return property(**locals()) + + @apply + def upper_limit_actual_translation(): + def fget( self ): + return self._upper_limit_actual_translation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_translation is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._upper_limit_actual_translation = translational_range_measure(value) + else: + self._upper_limit_actual_translation = value + return property(**locals()) + + @apply + def lower_limit_actual_rotation(): + def fget( self ): + return self._lower_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_actual_rotation = rotational_range_measure(value) + else: + self._lower_limit_actual_rotation = value + return property(**locals()) + + @apply + def upper_limit_actual_rotation(): + def fget( self ): + return self._upper_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_actual_rotation = rotational_range_measure(value) + else: + self._upper_limit_actual_rotation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_translation)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_translation))) XOR (self.lower_limit_actual_translation < self.upper_limit_actual_translation)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_rotation)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_rotation))) XOR (self.lower_limit_actual_rotation < self.upper_limit_actual_rotation)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY description_attribute # +#################### +class description_attribute(BaseEntityClass): + '''Entity description_attribute definition. + + :param attribute_value + :type attribute_value:text + + :param described_item + :type described_item:description_attribute_select + ''' + def __init__( self , attribute_value,described_item, ): + self.attribute_value = attribute_value + self.described_item = described_item + + @apply + def attribute_value(): + def fget( self ): + return self._attribute_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument attribute_value is mantatory and can not be set to None') + if not check_type(value,text): + self._attribute_value = text(value) + else: + self._attribute_value = value + return property(**locals()) + + @apply + def described_item(): + def fget( self ): + return self._described_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument described_item is mantatory and can not be set to None') + if not check_type(value,description_attribute_select): + self._described_item = description_attribute_select(value) + else: + self._described_item = value + return property(**locals()) + +#################### + # ENTITY half_space_solid # +#################### +class half_space_solid(geometric_representation_item): + '''Entity half_space_solid definition. + + :param base_surface + :type base_surface:surface + + :param agreement_flag + :type agreement_flag:BOOLEAN + ''' + def __init__( self , inherited0__name , base_surface,agreement_flag, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.base_surface = base_surface + self.agreement_flag = agreement_flag + + @apply + def base_surface(): + def fget( self ): + return self._base_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument base_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._base_surface = surface(value) + else: + self._base_surface = value + return property(**locals()) + + @apply + def agreement_flag(): + def fget( self ): + return self._agreement_flag + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument agreement_flag is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._agreement_flag = BOOLEAN(value) + else: + self._agreement_flag = value + return property(**locals()) + +#################### + # ENTITY action_request_solution # +#################### +class action_request_solution(BaseEntityClass): + '''Entity action_request_solution definition. + + :param method + :type method:action_method + + :param request + :type request:versioned_action_request + + :param description + :type description:text + + :param name + :type name:label + ''' + def __init__( self , method,request, ): + self.method = method + self.request = request + + @apply + def method(): + def fget( self ): + return self._method + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument method is mantatory and can not be set to None') + if not check_type(value,action_method): + self._method = action_method(value) + else: + self._method = value + return property(**locals()) + + @apply + def request(): + def fget( self ): + return self._request + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument request is mantatory and can not be set to None') + if not check_type(value,versioned_action_request): + self._request = versioned_action_request(value) + else: + self._request = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY group # +#################### +class group(BaseEntityClass): + '''Entity group definition. + + :param name + :type name:label + + :param description + :type description:text + + :param id + :type id:identifier + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def id(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument id is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_concept_feature_category # +#################### +class product_concept_feature_category(group): + '''Entity product_concept_feature_category definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + group.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY exclusive_product_concept_feature_category # +#################### +class exclusive_product_concept_feature_category(product_concept_feature_category): + '''Entity exclusive_product_concept_feature_category definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + product_concept_feature_category.__init__(self , inherited0__name , inherited1__description , ) + +#################### + # ENTITY over_riding_styled_item # +#################### +class over_riding_styled_item(styled_item): + '''Entity over_riding_styled_item definition. + + :param over_ridden_style + :type over_ridden_style:styled_item + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , over_ridden_style, ): + styled_item.__init__(self , inherited0__name , inherited1__styles , inherited2__item , ) + self.over_ridden_style = over_ridden_style + + @apply + def over_ridden_style(): + def fget( self ): + return self._over_ridden_style + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument over_ridden_style is mantatory and can not be set to None') + if not check_type(value,styled_item): + self._over_ridden_style = styled_item(value) + else: + self._over_ridden_style = value + return property(**locals()) + +#################### + # ENTITY context_dependent_over_riding_styled_item # +#################### +class context_dependent_over_riding_styled_item(over_riding_styled_item): + '''Entity context_dependent_over_riding_styled_item definition. + + :param style_context + :type style_context:LIST(1,None,'style_context_select', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__over_ridden_style , style_context, ): + over_riding_styled_item.__init__(self , inherited0__name , inherited1__styles , inherited2__item , inherited3__over_ridden_style , ) + self.style_context = style_context + + @apply + def style_context(): + def fget( self ): + return self._style_context + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument style_context is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'style_context_select', scope = schema_scope)): + self._style_context = LIST(value) + else: + self._style_context = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (((SIZEOF(None) == 1) or (SIZEOF(None) == SIZEOF(self.style_context))) or (SIZEOF(None) == SIZEOF(self.style_context))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY hidden_element_over_riding_styled_item # +#################### +class hidden_element_over_riding_styled_item(context_dependent_over_riding_styled_item): + '''Entity hidden_element_over_riding_styled_item definition. + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__over_ridden_style , inherited4__style_context , ): + context_dependent_over_riding_styled_item.__init__(self , inherited0__name , inherited1__styles , inherited2__item , inherited3__over_ridden_style , inherited4__style_context , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.style_context) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (('AUTOMOTIVE_DESIGN.' + 'PRESENTATION_VIEW') == TYPEOF(self.self.style_context[1])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (('AUTOMOTIVE_DESIGN.' + 'CAMERA_IMAGE') == TYPEOF(self.self.item)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (('AUTOMOTIVE_DESIGN.' + 'CAMERA_MODEL_D3_WITH_HLHSR') == TYPEOF(self.self.item.self.mapped_item.self.mapping_source.self.mapping_origin)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) > 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY presentation_size # +#################### +class presentation_size(BaseEntityClass): + '''Entity presentation_size definition. + + :param unit + :type unit:presentation_size_assignment_select + + :param size + :type size:planar_box + ''' + def __init__( self , unit,size, ): + self.unit = unit + self.size = size + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unit is mantatory and can not be set to None') + if not check_type(value,presentation_size_assignment_select): + self._unit = presentation_size_assignment_select(value) + else: + self._unit = value + return property(**locals()) + + @apply + def size(): + def fget( self ): + return self._size + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument size is mantatory and can not be set to None') + if not check_type(value,planar_box): + self._size = planar_box(value) + else: + self._size = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.PRESENTATION_REPRESENTATION' == TYPEOF(self.self.unit)) and item_in_context(self.self.size,self.self.unit.self.representation.self.context_of_items)) or (('AUTOMOTIVE_DESIGN.AREA_IN_SET' == TYPEOF(self.self.unit)) and (SIZEOF(None) == 0))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY uncertainty_measure_with_unit # +#################### +class uncertainty_measure_with_unit(measure_with_unit): + '''Entity uncertainty_measure_with_unit definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , name,description, ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = valid_measure_value(self.self.measure_with_unit.self.value_component) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY edge_based_wireframe_model # +#################### +class edge_based_wireframe_model(geometric_representation_item): + '''Entity edge_based_wireframe_model definition. + + :param ebwm_boundary + :type ebwm_boundary:SET(1,None,'connected_edge_set', scope = schema_scope) + ''' + def __init__( self , inherited0__name , ebwm_boundary, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.ebwm_boundary = ebwm_boundary + + @apply + def ebwm_boundary(): + def fget( self ): + return self._ebwm_boundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ebwm_boundary is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'connected_edge_set', scope = schema_scope)): + self._ebwm_boundary = SET(value) + else: + self._ebwm_boundary = value + return property(**locals()) + +#################### + # ENTITY rack_and_pinion_pair_value # +#################### +class rack_and_pinion_pair_value(pair_value): + '''Entity rack_and_pinion_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:rack_and_pinion_pair + + :param actual_displacement + :type actual_displacement:length_measure + + :param actual_rotation + :type actual_rotation:plane_angle_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_displacement, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_displacement = actual_displacement + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,rack_and_pinion_pair): + self._pair_value_applies_to_pair = rack_and_pinion_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_displacement(): + def fget( self ): + return self._actual_displacement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_displacement is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._actual_displacement = length_measure(value) + else: + self._actual_displacement = value + return property(**locals()) + + @apply + def actual_rotation(): + def fget( self ): + attribute_eval = convert_plane_angle_for_pair_from_radian(self.self.pair_value.self.applies_to_pair,(-self.actual_displacement) / self.self.pair_value.self.applies_to_pair.self.rack_and_pinion_pair.self.pinion_radius) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument actual_rotation is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY pre_defined_colour # +#################### +class pre_defined_colour(pre_defined_item,colour): + '''Entity pre_defined_colour definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_item.__init__(self , inherited0__name , ) + colour.__init__(self , ) + +#################### + # ENTITY draughting_pre_defined_colour # +#################### +class draughting_pre_defined_colour(pre_defined_colour): + '''Entity draughting_pre_defined_colour definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_colour.__init__(self , inherited0__name , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['red','green','blue','yellow','magenta','cyan','black','white']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY path # +#################### +class path(topological_representation_item): + '''Entity path definition. + + :param edge_list + :type edge_list:LIST(1,None,'oriented_edge', scope = schema_scope) + ''' + def __init__( self , inherited0__name , edge_list, ): + topological_representation_item.__init__(self , inherited0__name , ) + self.edge_list = edge_list + + @apply + def edge_list(): + def fget( self ): + return self._edge_list + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edge_list is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'oriented_edge', scope = schema_scope)): + self._edge_list = LIST(value) + else: + self._edge_list = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = path_head_to_tail(self) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY feature_component_definition # +#################### +class feature_component_definition(characterized_object): + '''Entity feature_component_definition definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + characterized_object.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(get_shape_aspects(self)) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY connected_face_set # +#################### +class connected_face_set(topological_representation_item): + '''Entity connected_face_set definition. + + :param cfs_faces + :type cfs_faces:SET(1,None,'face', scope = schema_scope) + ''' + def __init__( self , inherited0__name , cfs_faces, ): + topological_representation_item.__init__(self , inherited0__name , ) + self.cfs_faces = cfs_faces + + @apply + def cfs_faces(): + def fget( self ): + return self._cfs_faces + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument cfs_faces is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'face', scope = schema_scope)): + self._cfs_faces = SET(value) + else: + self._cfs_faces = value + return property(**locals()) + +#################### + # ENTITY open_shell # +#################### +class open_shell(connected_face_set): + '''Entity open_shell definition. + ''' + def __init__( self , inherited0__name , inherited1__cfs_faces , ): + connected_face_set.__init__(self , inherited0__name , inherited1__cfs_faces , ) + +#################### + # ENTITY oriented_open_shell # +#################### +class oriented_open_shell(open_shell): + '''Entity oriented_open_shell definition. + + :param open_shell_element + :type open_shell_element:open_shell + + :param orientation + :type orientation:BOOLEAN + + :param connected_face_set_cfs_faces + :type connected_face_set_cfs_faces:SET(1,None,'face', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__cfs_faces , open_shell_element,orientation, ): + open_shell.__init__(self , inherited0__name , inherited1__cfs_faces , ) + self.open_shell_element = open_shell_element + self.orientation = orientation + + @apply + def open_shell_element(): + def fget( self ): + return self._open_shell_element + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument open_shell_element is mantatory and can not be set to None') + if not check_type(value,open_shell): + self._open_shell_element = open_shell(value) + else: + self._open_shell_element = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def connected_face_set_cfs_faces(): + def fget( self ): + attribute_eval = conditional_reverse(self.self.orientation,self.self.open_shell_element.self.cfs_faces) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument connected_face_set_cfs_faces is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('AUTOMOTIVE_DESIGN.ORIENTED_OPEN_SHELL' == TYPEOF(self.self.open_shell_element))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY tolerance_zone # +#################### +class tolerance_zone(shape_aspect): + '''Entity tolerance_zone definition. + + :param defining_tolerance + :type defining_tolerance:SET(1,None,'geometric_tolerance', scope = schema_scope) + + :param form + :type form:tolerance_zone_form + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , defining_tolerance,form, ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + self.defining_tolerance = defining_tolerance + self.form = form + + @apply + def defining_tolerance(): + def fget( self ): + return self._defining_tolerance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument defining_tolerance is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'geometric_tolerance', scope = schema_scope)): + self._defining_tolerance = SET(value) + else: + self._defining_tolerance = value + return property(**locals()) + + @apply + def form(): + def fget( self ): + return self._form + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument form is mantatory and can not be set to None') + if not check_type(value,tolerance_zone_form): + self._form = tolerance_zone_form(value) + else: + self._form = value + return property(**locals()) + +#################### + # ENTITY right_circular_cylinder # +#################### +class right_circular_cylinder(geometric_representation_item): + '''Entity right_circular_cylinder definition. + + :param position + :type position:axis1_placement + + :param height + :type height:positive_length_measure + + :param radius + :type radius:positive_length_measure + ''' + def __init__( self , inherited0__name , position,height,radius, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.position = position + self.height = height + self.radius = radius + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,axis1_placement): + self._position = axis1_placement(value) + else: + self._position = value + return property(**locals()) + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._height = positive_length_measure(value) + else: + self._height = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._radius = positive_length_measure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY solid_angle_unit # +#################### +class solid_angle_unit(named_unit): + '''Entity solid_angle_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 0) and (self.self.named_unit.self.dimensions.self.mass_exponent == 0)) and (self.self.named_unit.self.dimensions.self.time_exponent == 0)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 0)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 0)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 0)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY boolean_defined_function # +#################### +class boolean_defined_function(defined_function,boolean_expression): + '''Entity boolean_defined_function definition. + ''' + def __init__( self , ): + defined_function.__init__(self , ) + boolean_expression.__init__(self , ) + +#################### + # ENTITY luminous_intensity_measure_with_unit # +#################### +class luminous_intensity_measure_with_unit(measure_with_unit): + '''Entity luminous_intensity_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.LUMINOUS_INTENSITY_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY representation_relationship_with_transformation # +#################### +class representation_relationship_with_transformation(representation_relationship): + '''Entity representation_relationship_with_transformation definition. + + :param transformation_operator + :type transformation_operator:transformation + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , transformation_operator, ): + representation_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , ) + self.transformation_operator = transformation_operator + + @apply + def transformation_operator(): + def fget( self ): + return self._transformation_operator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transformation_operator is mantatory and can not be set to None') + if not check_type(value,transformation): + self._transformation_operator = transformation(value) + else: + self._transformation_operator = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.representation_relationship.self.rep_1.self.context_of_items != self.self.representation_relationship.self.rep_2.self.context_of_items) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY mechanism_base_placement # +#################### +class mechanism_base_placement(representation_relationship_with_transformation): + '''Entity mechanism_base_placement definition. + + :param base_of_mechanism + :type base_of_mechanism:mechanism + + :param representation_relationship_with_transformation_transformation_operator + :type representation_relationship_with_transformation_transformation_operator:cartesian_transformation_operator_3d + + :param representation_relationship_rep_2 + :type representation_relationship_rep_2:kinematic_link_representation + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , inherited4__transformation_operator , base_of_mechanism,representation_relationship_with_transformation_transformation_operator, ): + representation_relationship_with_transformation.__init__(self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , inherited4__transformation_operator , ) + self.base_of_mechanism = base_of_mechanism + self.representation_relationship_with_transformation_transformation_operator = representation_relationship_with_transformation_transformation_operator + + @apply + def base_of_mechanism(): + def fget( self ): + return self._base_of_mechanism + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument base_of_mechanism is mantatory and can not be set to None') + if not check_type(value,mechanism): + self._base_of_mechanism = mechanism(value) + else: + self._base_of_mechanism = value + return property(**locals()) + + @apply + def representation_relationship_with_transformation_transformation_operator(): + def fget( self ): + return self._representation_relationship_with_transformation_transformation_operator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_relationship_with_transformation_transformation_operator is mantatory and can not be set to None') + if not check_type(value,cartesian_transformation_operator_3d): + self._representation_relationship_with_transformation_transformation_operator = cartesian_transformation_operator_3d(value) + else: + self._representation_relationship_with_transformation_transformation_operator = value + return property(**locals()) + + @apply + def representation_relationship_rep_2(): + def fget( self ): + attribute_eval = representation_of_link(self.base_of_mechanism.self.base) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument representation_relationship_rep_2 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.KINEMATIC_GROUND_REPRESENTATION' == TYPEOF(self.self.representation_relationship.self.rep_1)) or ('AUTOMOTIVE_DESIGN.KINEMATIC_LINK_REPRESENTATION' == TYPEOF(self.self.representation_relationship.self.rep_1))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = suitably_based_mechanism(self,self.base_of_mechanism) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.self.representation_relationship_with_transformation.self.transformation_operator == self.self.representation_relationship.self.rep_1.self.items) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY role_association # +#################### +class role_association(BaseEntityClass): + '''Entity role_association definition. + + :param role + :type role:object_role + + :param item_with_role + :type item_with_role:role_select + ''' + def __init__( self , role,item_with_role, ): + self.role = role + self.item_with_role = item_with_role + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,object_role): + self._role = object_role(value) + else: + self._role = value + return property(**locals()) + + @apply + def item_with_role(): + def fget( self ): + return self._item_with_role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_with_role is mantatory and can not be set to None') + if not check_type(value,role_select): + self._item_with_role = role_select(value) + else: + self._item_with_role = value + return property(**locals()) + +#################### + # ENTITY rectangular_closed_profile # +#################### +class rectangular_closed_profile(shape_aspect): + '''Entity rectangular_closed_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + +#################### + # ENTITY comparison_less # +#################### +class comparison_less(comparison_expression): + '''Entity comparison_less definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + comparison_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY coordinated_universal_time_offset # +#################### +class coordinated_universal_time_offset(BaseEntityClass): + '''Entity coordinated_universal_time_offset definition. + + :param hour_offset + :type hour_offset:INTEGER + + :param minute_offset + :type minute_offset:INTEGER + + :param sense + :type sense:ahead_or_behind + + :param actual_minute_offset + :type actual_minute_offset:INTEGER + ''' + def __init__( self , hour_offset,minute_offset,sense, ): + self.hour_offset = hour_offset + self.minute_offset = minute_offset + self.sense = sense + + @apply + def hour_offset(): + def fget( self ): + return self._hour_offset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hour_offset is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._hour_offset = INTEGER(value) + else: + self._hour_offset = value + return property(**locals()) + + @apply + def minute_offset(): + def fget( self ): + return self._minute_offset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,INTEGER): + self._minute_offset = INTEGER(value) + else: + self._minute_offset = value + else: + self._minute_offset = value + return property(**locals()) + + @apply + def sense(): + def fget( self ): + return self._sense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sense is mantatory and can not be set to None') + if not check_type(value,ahead_or_behind): + self._sense = ahead_or_behind(value) + else: + self._sense = value + return property(**locals()) + + @apply + def actual_minute_offset(): + def fget( self ): + attribute_eval = NVL(self.minute_offset,0) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument actual_minute_offset is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((0 <= self.hour_offset) and (self.hour_offset < 24)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((0 <= self.actual_minute_offset) and (self.actual_minute_offset <= 59)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ( not (((self.hour_offset != 0) or (self.actual_minute_offset != 0)) and (self.sense == exact))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY curve_replica # +#################### +class curve_replica(curve): + '''Entity curve_replica definition. + + :param parent_curve + :type parent_curve:curve + + :param transformation + :type transformation:cartesian_transformation_operator + ''' + def __init__( self , inherited0__name , parent_curve,transformation, ): + curve.__init__(self , inherited0__name , ) + self.parent_curve = parent_curve + self.transformation = transformation + + @apply + def parent_curve(): + def fget( self ): + return self._parent_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parent_curve is mantatory and can not be set to None') + if not check_type(value,curve): + self._parent_curve = curve(value) + else: + self._parent_curve = value + return property(**locals()) + + @apply + def transformation(): + def fget( self ): + return self._transformation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transformation is mantatory and can not be set to None') + if not check_type(value,cartesian_transformation_operator): + self._transformation = cartesian_transformation_operator(value) + else: + self._transformation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.transformation.self.dim == self.parent_curve.self.dim) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = acyclic_curve_replica(self,self.parent_curve) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY swept_face_solid # +#################### +class swept_face_solid(solid_model): + '''Entity swept_face_solid definition. + + :param swept_face + :type swept_face:face_surface + ''' + def __init__( self , inherited0__name , swept_face, ): + solid_model.__init__(self , inherited0__name , ) + self.swept_face = swept_face + + @apply + def swept_face(): + def fget( self ): + return self._swept_face + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument swept_face is mantatory and can not be set to None') + if not check_type(value,face_surface): + self._swept_face = face_surface(value) + else: + self._swept_face = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.PLANE' == TYPEOF(self.swept_face.self.face_geometry)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY extruded_face_solid # +#################### +class extruded_face_solid(swept_face_solid): + '''Entity extruded_face_solid definition. + + :param extruded_direction + :type extruded_direction:direction + + :param depth + :type depth:positive_length_measure + ''' + def __init__( self , inherited0__name , inherited1__swept_face , extruded_direction,depth, ): + swept_face_solid.__init__(self , inherited0__name , inherited1__swept_face , ) + self.extruded_direction = extruded_direction + self.depth = depth + + @apply + def extruded_direction(): + def fget( self ): + return self._extruded_direction + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extruded_direction is mantatory and can not be set to None') + if not check_type(value,direction): + self._extruded_direction = direction(value) + else: + self._extruded_direction = value + return property(**locals()) + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._depth = positive_length_measure(value) + else: + self._depth = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (dot_product(self.self.swept_face_solid.self.swept_face.self.face_geometry.self.elementary_surface.self.position.self.p[3],self.extruded_direction) != 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY quasi_uniform_surface # +#################### +class quasi_uniform_surface(b_spline_surface): + '''Entity quasi_uniform_surface definition. + ''' + def __init__( self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , ): + b_spline_surface.__init__(self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , ) + +#################### + # ENTITY surface_curve # +#################### +class surface_curve(curve): + '''Entity surface_curve definition. + + :param curve_3d + :type curve_3d:curve + + :param associated_geometry + :type associated_geometry:LIST(1,2,'pcurve_or_surface', scope = schema_scope) + + :param master_representation + :type master_representation:preferred_surface_curve_representation + + :param basis_surface + :type basis_surface:SET(1,2,'surface', scope = schema_scope) + ''' + def __init__( self , inherited0__name , curve_3d,associated_geometry,master_representation, ): + curve.__init__(self , inherited0__name , ) + self.curve_3d = curve_3d + self.associated_geometry = associated_geometry + self.master_representation = master_representation + + @apply + def curve_3d(): + def fget( self ): + return self._curve_3d + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curve_3d is mantatory and can not be set to None') + if not check_type(value,curve): + self._curve_3d = curve(value) + else: + self._curve_3d = value + return property(**locals()) + + @apply + def associated_geometry(): + def fget( self ): + return self._associated_geometry + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument associated_geometry is mantatory and can not be set to None') + if not check_type(value,LIST(1,2,'pcurve_or_surface', scope = schema_scope)): + self._associated_geometry = LIST(value) + else: + self._associated_geometry = value + return property(**locals()) + + @apply + def master_representation(): + def fget( self ): + return self._master_representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument master_representation is mantatory and can not be set to None') + if not check_type(value,preferred_surface_curve_representation): + self._master_representation = preferred_surface_curve_representation(value) + else: + self._master_representation = value + return property(**locals()) + + @apply + def basis_surface(): + def fget( self ): + attribute_eval = get_basis_surface(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument basis_surface is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.curve_3d.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(self.associated_geometry[1])) or (self.master_representation != pcurve_s1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(self.associated_geometry[2])) or (self.master_representation != pcurve_s2)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ( not ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(self.curve_3d))) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY surface_style_rendering # +#################### +class surface_style_rendering(BaseEntityClass): + '''Entity surface_style_rendering definition. + + :param rendering_method + :type rendering_method:shading_surface_method + + :param surface_colour + :type surface_colour:colour + ''' + def __init__( self , rendering_method,surface_colour, ): + self.rendering_method = rendering_method + self.surface_colour = surface_colour + + @apply + def rendering_method(): + def fget( self ): + return self._rendering_method + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rendering_method is mantatory and can not be set to None') + if not check_type(value,shading_surface_method): + self._rendering_method = shading_surface_method(value) + else: + self._rendering_method = value + return property(**locals()) + + @apply + def surface_colour(): + def fget( self ): + return self._surface_colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument surface_colour is mantatory and can not be set to None') + if not check_type(value,colour): + self._surface_colour = colour(value) + else: + self._surface_colour = value + return property(**locals()) + +#################### + # ENTITY action_request_status # +#################### +class action_request_status(BaseEntityClass): + '''Entity action_request_status definition. + + :param status + :type status:label + + :param assigned_request + :type assigned_request:versioned_action_request + ''' + def __init__( self , status,assigned_request, ): + self.status = status + self.assigned_request = assigned_request + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument status is mantatory and can not be set to None') + if not check_type(value,label): + self._status = label(value) + else: + self._status = value + return property(**locals()) + + @apply + def assigned_request(): + def fget( self ): + return self._assigned_request + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_request is mantatory and can not be set to None') + if not check_type(value,versioned_action_request): + self._assigned_request = versioned_action_request(value) + else: + self._assigned_request = value + return property(**locals()) + +#################### + # ENTITY fill_area_style # +#################### +class fill_area_style(founded_item): + '''Entity fill_area_style definition. + + :param name + :type name:label + + :param fill_styles + :type fill_styles:SET(1,None,'fill_style_select', scope = schema_scope) + ''' + def __init__( self , name,fill_styles, ): + founded_item.__init__(self , ) + self.name = name + self.fill_styles = fill_styles + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def fill_styles(): + def fget( self ): + return self._fill_styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fill_styles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'fill_style_select', scope = schema_scope)): + self._fill_styles = SET(value) + else: + self._fill_styles = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY universal_pair_range # +#################### +class universal_pair_range(simple_pair_range): + '''Entity universal_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:universal_pair + + :param lower_limit_first_rotation + :type lower_limit_first_rotation:rotational_range_measure + + :param upper_limit_first_rotation + :type upper_limit_first_rotation:rotational_range_measure + + :param lower_limit_second_rotation + :type lower_limit_second_rotation:rotational_range_measure + + :param upper_limit_second_rotation + :type upper_limit_second_rotation:rotational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,lower_limit_first_rotation,upper_limit_first_rotation,lower_limit_second_rotation,upper_limit_second_rotation, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.lower_limit_first_rotation = lower_limit_first_rotation + self.upper_limit_first_rotation = upper_limit_first_rotation + self.lower_limit_second_rotation = lower_limit_second_rotation + self.upper_limit_second_rotation = upper_limit_second_rotation + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,universal_pair): + self._simple_pair_range_applies_to_pair = universal_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def lower_limit_first_rotation(): + def fget( self ): + return self._lower_limit_first_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_first_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_first_rotation = rotational_range_measure(value) + else: + self._lower_limit_first_rotation = value + return property(**locals()) + + @apply + def upper_limit_first_rotation(): + def fget( self ): + return self._upper_limit_first_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_first_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_first_rotation = rotational_range_measure(value) + else: + self._upper_limit_first_rotation = value + return property(**locals()) + + @apply + def lower_limit_second_rotation(): + def fget( self ): + return self._lower_limit_second_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_second_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_second_rotation = rotational_range_measure(value) + else: + self._lower_limit_second_rotation = value + return property(**locals()) + + @apply + def upper_limit_second_rotation(): + def fget( self ): + return self._upper_limit_second_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_second_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_second_rotation = rotational_range_measure(value) + else: + self._upper_limit_second_rotation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_first_rotation)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_first_rotation))) XOR (self.lower_limit_first_rotation < self.upper_limit_first_rotation)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_second_rotation)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_second_rotation))) XOR (self.lower_limit_second_rotation < self.upper_limit_second_rotation)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY planar_pair_value # +#################### +class planar_pair_value(pair_value): + '''Entity planar_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:planar_pair + + :param actual_rotation + :type actual_rotation:plane_angle_measure + + :param actual_translation_x + :type actual_translation_x:length_measure + + :param actual_translation_y + :type actual_translation_y:length_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_rotation,actual_translation_x,actual_translation_y, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_rotation = actual_rotation + self.actual_translation_x = actual_translation_x + self.actual_translation_y = actual_translation_y + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,planar_pair): + self._pair_value_applies_to_pair = planar_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_rotation(): + def fget( self ): + return self._actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_rotation is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._actual_rotation = plane_angle_measure(value) + else: + self._actual_rotation = value + return property(**locals()) + + @apply + def actual_translation_x(): + def fget( self ): + return self._actual_translation_x + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_translation_x is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._actual_translation_x = length_measure(value) + else: + self._actual_translation_x = value + return property(**locals()) + + @apply + def actual_translation_y(): + def fget( self ): + return self._actual_translation_y + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_translation_y is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._actual_translation_y = length_measure(value) + else: + self._actual_translation_y = value + return property(**locals()) + +#################### + # ENTITY action_resource_requirement # +#################### +class action_resource_requirement(BaseEntityClass): + '''Entity action_resource_requirement definition. + + :param name + :type name:label + + :param description + :type description:text + + :param kind + :type kind:resource_requirement_type + + :param operations + :type operations:SET(1,None,'characterized_action_definition', scope = schema_scope) + ''' + def __init__( self , name,description,kind,operations, ): + self.name = name + self.description = description + self.kind = kind + self.operations = operations + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def kind(): + def fget( self ): + return self._kind + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument kind is mantatory and can not be set to None') + if not check_type(value,resource_requirement_type): + self._kind = resource_requirement_type(value) + else: + self._kind = value + return property(**locals()) + + @apply + def operations(): + def fget( self ): + return self._operations + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operations is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'characterized_action_definition', scope = schema_scope)): + self._operations = SET(value) + else: + self._operations = value + return property(**locals()) + +#################### + # ENTITY requirement_for_action_resource # +#################### +class requirement_for_action_resource(action_resource_requirement): + '''Entity requirement_for_action_resource definition. + + :param resources + :type resources:SET(1,None,'action_resource', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__kind , inherited3__operations , resources, ): + action_resource_requirement.__init__(self , inherited0__name , inherited1__description , inherited2__kind , inherited3__operations , ) + self.resources = resources + + @apply + def resources(): + def fget( self ): + return self._resources + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument resources is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'action_resource', scope = schema_scope)): + self._resources = SET(value) + else: + self._resources = value + return property(**locals()) + +#################### + # ENTITY slot_end # +#################### +class slot_end(shape_aspect): + '''Entity slot_end definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.description == ['open','radiused','flat','woodruff']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((self.self.description == ['open','radiused']) XOR (SIZEOF(None) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (self.self.description == ['flat','woodruff'])) XOR (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'flat') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'flat') or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((self.self.description != 'flat') or (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((self.self.description != 'woodruff') or (SIZEOF(None) == 1)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = ((self.self.description != 'woodruff') or (SIZEOF(None) == 1)) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) == 1) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + +#################### + # ENTITY closed_path_profile # +#################### +class closed_path_profile(shape_aspect): + '''Entity closed_path_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + +#################### + # ENTITY hole_in_panel # +#################### +class hole_in_panel(feature_definition): + '''Entity hole_in_panel definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(get_property_definition_representations(self)) == SIZEOF(None)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY transition_feature # +#################### +class transition_feature(shape_aspect): + '''Entity transition_feature definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'PRODUCT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'CHAMFER','AUTOMOTIVE_DESIGN.' + 'EDGE_ROUND','AUTOMOTIVE_DESIGN.' + 'FILLET'] * TYPEOF(self)) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY edge_round # +#################### +class edge_round(transition_feature): + '''Entity edge_round definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + transition_feature.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = ((self.self.description != 'constant radius') XOR (SIZEOF(None) == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 1) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + +#################### + # ENTITY kinematic_frame_background_representation_association # +#################### +class kinematic_frame_background_representation_association(representation_relationship_with_transformation): + '''Entity kinematic_frame_background_representation_association definition. + + :param representation_relationship_with_transformation_transformation_operator + :type representation_relationship_with_transformation_transformation_operator:kinematic_frame_based_transformation + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , inherited4__transformation_operator , representation_relationship_with_transformation_transformation_operator, ): + representation_relationship_with_transformation.__init__(self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , inherited4__transformation_operator , ) + self.representation_relationship_with_transformation_transformation_operator = representation_relationship_with_transformation_transformation_operator + + @apply + def representation_relationship_with_transformation_transformation_operator(): + def fget( self ): + return self._representation_relationship_with_transformation_transformation_operator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_relationship_with_transformation_transformation_operator is mantatory and can not be set to None') + if not check_type(value,kinematic_frame_based_transformation): + self._representation_relationship_with_transformation_transformation_operator = kinematic_frame_based_transformation(value) + else: + self._representation_relationship_with_transformation_transformation_operator = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.KINEMATIC_LINK_REPRESENTATION' == TYPEOF(self.self.representation_relationship.self.rep_1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('AUTOMOTIVE_DESIGN.KINEMATIC_FRAME_BACKGROUND_REPRESENTATION' == TYPEOF(self.self.representation_relationship.self.rep_2)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.self.representation_relationship_with_transformation.self.transformation_operator.self.kinematic_frame_based_transformation.self.transformator == self.self.representation_relationship.self.rep_1.self.items) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY composite_curve_segment # +#################### +class composite_curve_segment(founded_item): + '''Entity composite_curve_segment definition. + + :param transition + :type transition:transition_code + + :param same_sense + :type same_sense:BOOLEAN + + :param parent_curve + :type parent_curve:curve + + :param using_curves + :type using_curves:BAG(1,None,'composite_curve', scope = schema_scope) + ''' + def __init__( self , transition,same_sense,parent_curve, ): + founded_item.__init__(self , ) + self.transition = transition + self.same_sense = same_sense + self.parent_curve = parent_curve + + @apply + def transition(): + def fget( self ): + return self._transition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transition is mantatory and can not be set to None') + if not check_type(value,transition_code): + self._transition = transition_code(value) + else: + self._transition = value + return property(**locals()) + + @apply + def same_sense(): + def fget( self ): + return self._same_sense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument same_sense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._same_sense = BOOLEAN(value) + else: + self._same_sense = value + return property(**locals()) + + @apply + def parent_curve(): + def fget( self ): + return self._parent_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parent_curve is mantatory and can not be set to None') + if not check_type(value,curve): + self._parent_curve = curve(value) + else: + self._parent_curve = value + return property(**locals()) + + @apply + def using_curves(): + def fget( self ): + return self._using_curves + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument using_curves is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.BOUNDED_CURVE' == TYPEOF(self.parent_curve)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY reparametrised_composite_curve_segment # +#################### +class reparametrised_composite_curve_segment(composite_curve_segment): + '''Entity reparametrised_composite_curve_segment definition. + + :param param_length + :type param_length:parameter_value + ''' + def __init__( self , inherited0__transition , inherited1__same_sense , inherited2__parent_curve , param_length, ): + composite_curve_segment.__init__(self , inherited0__transition , inherited1__same_sense , inherited2__parent_curve , ) + self.param_length = param_length + + @apply + def param_length(): + def fget( self ): + return self._param_length + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument param_length is mantatory and can not be set to None') + if not check_type(value,parameter_value): + self._param_length = parameter_value(value) + else: + self._param_length = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.param_length > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY class # +#################### +class class_(group): + '''Entity class definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + group.__init__(self , inherited0__name , inherited1__description , ) + +#################### + # ENTITY person_and_organization_role # +#################### +class person_and_organization_role(BaseEntityClass): + '''Entity person_and_organization_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY presentation_layer_assignment # +#################### +class presentation_layer_assignment(BaseEntityClass): + '''Entity presentation_layer_assignment definition. + + :param name + :type name:label + + :param description + :type description:text + + :param assigned_items + :type assigned_items:SET(1,None,'layered_item', scope = schema_scope) + ''' + def __init__( self , name,description,assigned_items, ): + self.name = name + self.description = description + self.assigned_items = assigned_items + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def assigned_items(): + def fget( self ): + return self._assigned_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'layered_item', scope = schema_scope)): + self._assigned_items = SET(value) + else: + self._assigned_items = value + return property(**locals()) + +#################### + # ENTITY quasi_uniform_curve # +#################### +class quasi_uniform_curve(b_spline_curve): + '''Entity quasi_uniform_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , ): + b_spline_curve.__init__(self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , ) + +#################### + # ENTITY swept_surface # +#################### +class swept_surface(surface): + '''Entity swept_surface definition. + + :param swept_curve + :type swept_curve:curve + ''' + def __init__( self , inherited0__name , swept_curve, ): + surface.__init__(self , inherited0__name , ) + self.swept_curve = swept_curve + + @apply + def swept_curve(): + def fget( self ): + return self._swept_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument swept_curve is mantatory and can not be set to None') + if not check_type(value,curve): + self._swept_curve = curve(value) + else: + self._swept_curve = value + return property(**locals()) + +#################### + # ENTITY concept_feature_relationship # +#################### +class concept_feature_relationship(BaseEntityClass): + '''Entity concept_feature_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_product_concept_feature + :type relating_product_concept_feature:product_concept_feature + + :param related_product_concept_feature + :type related_product_concept_feature:product_concept_feature + ''' + def __init__( self , name,description,relating_product_concept_feature,related_product_concept_feature, ): + self.name = name + self.description = description + self.relating_product_concept_feature = relating_product_concept_feature + self.related_product_concept_feature = related_product_concept_feature + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_product_concept_feature(): + def fget( self ): + return self._relating_product_concept_feature + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_product_concept_feature is mantatory and can not be set to None') + if not check_type(value,product_concept_feature): + self._relating_product_concept_feature = product_concept_feature(value) + else: + self._relating_product_concept_feature = value + return property(**locals()) + + @apply + def related_product_concept_feature(): + def fget( self ): + return self._related_product_concept_feature + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_product_concept_feature is mantatory and can not be set to None') + if not check_type(value,product_concept_feature): + self._related_product_concept_feature = product_concept_feature(value) + else: + self._related_product_concept_feature = value + return property(**locals()) + +#################### + # ENTITY concept_feature_relationship_with_condition # +#################### +class concept_feature_relationship_with_condition(concept_feature_relationship): + '''Entity concept_feature_relationship_with_condition definition. + + :param conditional_operator + :type conditional_operator:concept_feature_operator + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_product_concept_feature , inherited3__related_product_concept_feature , conditional_operator, ): + concept_feature_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_product_concept_feature , inherited3__related_product_concept_feature , ) + self.conditional_operator = conditional_operator + + @apply + def conditional_operator(): + def fget( self ): + return self._conditional_operator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument conditional_operator is mantatory and can not be set to None') + if not check_type(value,concept_feature_operator): + self._conditional_operator = concept_feature_operator(value) + else: + self._conditional_operator = value + return property(**locals()) + +#################### + # ENTITY kinematic_link_representation # +#################### +class kinematic_link_representation(representation): + '''Entity kinematic_link_representation definition. + + :param representation_context_of_items + :type representation_context_of_items:geometric_representation_context + + :param link_frame + :type link_frame:geometric_representation_context + + :param link_representation_relation + :type link_representation_relation:kinematic_link_representation_relation + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , representation_context_of_items, ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + self.representation_context_of_items = representation_context_of_items + + @apply + def representation_context_of_items(): + def fget( self ): + return self._representation_context_of_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_context_of_items is mantatory and can not be set to None') + if not check_type(value,geometric_representation_context): + self._representation_context_of_items = geometric_representation_context(value) + else: + self._representation_context_of_items = value + return property(**locals()) + + @apply + def link_frame(): + def fget( self ): + attribute_eval = self.self.representation.self.context_of_items + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument link_frame is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def link_representation_relation(): + def fget( self ): + return self._link_representation_relation + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument link_representation_relation is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY presented_item_representation # +#################### +class presented_item_representation(BaseEntityClass): + '''Entity presented_item_representation definition. + + :param presentation + :type presentation:presentation_representation_select + + :param item + :type item:presented_item + ''' + def __init__( self , presentation,item, ): + self.presentation = presentation + self.item = item + + @apply + def presentation(): + def fget( self ): + return self._presentation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument presentation is mantatory and can not be set to None') + if not check_type(value,presentation_representation_select): + self._presentation = presentation_representation_select(value) + else: + self._presentation = value + return property(**locals()) + + @apply + def item(): + def fget( self ): + return self._item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item is mantatory and can not be set to None') + if not check_type(value,presented_item): + self._item = presented_item(value) + else: + self._item = value + return property(**locals()) + +#################### + # ENTITY straightness_tolerance # +#################### +class straightness_tolerance(geometric_tolerance): + '''Entity straightness_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + def wr1(self): + eval_wr1_wr = ( not (('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE') == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY angular_location # +#################### +class angular_location(dimensional_location): + '''Entity angular_location definition. + + :param angle_selection + :type angle_selection:angle_relator + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , angle_selection, ): + dimensional_location.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + self.angle_selection = angle_selection + + @apply + def angle_selection(): + def fget( self ): + return self._angle_selection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument angle_selection is mantatory and can not be set to None') + if not check_type(value,angle_relator): + self._angle_selection = angle_relator(value) + else: + self._angle_selection = value + return property(**locals()) + +#################### + # ENTITY applied_action_request_assignment # +#################### +class applied_action_request_assignment(action_request_assignment): + '''Entity applied_action_request_assignment definition. + + :param items + :type items:SET(1,None,'action_request_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_action_request , items, ): + action_request_assignment.__init__(self , inherited0__assigned_action_request , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'action_request_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY event_occurrence # +#################### +class event_occurrence(BaseEntityClass): + '''Entity event_occurrence definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , id,name,description, ): + self.id = id + self.name = name + self.description = description + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY relative_event_occurrence # +#################### +class relative_event_occurrence(event_occurrence): + '''Entity relative_event_occurrence definition. + + :param base_event + :type base_event:event_occurrence + + :param offset + :type offset:time_measure_with_unit + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , base_event,offset, ): + event_occurrence.__init__(self , inherited0__id , inherited1__name , inherited2__description , ) + self.base_event = base_event + self.offset = offset + + @apply + def base_event(): + def fget( self ): + return self._base_event + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument base_event is mantatory and can not be set to None') + if not check_type(value,event_occurrence): + self._base_event = event_occurrence(value) + else: + self._base_event = value + return property(**locals()) + + @apply + def offset(): + def fget( self ): + return self._offset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument offset is mantatory and can not be set to None') + if not check_type(value,time_measure_with_unit): + self._offset = time_measure_with_unit(value) + else: + self._offset = value + return property(**locals()) + +#################### + # ENTITY spherical_pair_range # +#################### +class spherical_pair_range(simple_pair_range): + '''Entity spherical_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:spherical_pair + + :param lower_limit_yaw + :type lower_limit_yaw:rotational_range_measure + + :param upper_limit_yaw + :type upper_limit_yaw:rotational_range_measure + + :param lower_limit_pitch + :type lower_limit_pitch:rotational_range_measure + + :param upper_limit_pitch + :type upper_limit_pitch:rotational_range_measure + + :param lower_limit_roll + :type lower_limit_roll:rotational_range_measure + + :param upper_limit_roll + :type upper_limit_roll:rotational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,lower_limit_yaw,upper_limit_yaw,lower_limit_pitch,upper_limit_pitch,lower_limit_roll,upper_limit_roll, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.lower_limit_yaw = lower_limit_yaw + self.upper_limit_yaw = upper_limit_yaw + self.lower_limit_pitch = lower_limit_pitch + self.upper_limit_pitch = upper_limit_pitch + self.lower_limit_roll = lower_limit_roll + self.upper_limit_roll = upper_limit_roll + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,spherical_pair): + self._simple_pair_range_applies_to_pair = spherical_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def lower_limit_yaw(): + def fget( self ): + return self._lower_limit_yaw + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_yaw is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_yaw = rotational_range_measure(value) + else: + self._lower_limit_yaw = value + return property(**locals()) + + @apply + def upper_limit_yaw(): + def fget( self ): + return self._upper_limit_yaw + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_yaw is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_yaw = rotational_range_measure(value) + else: + self._upper_limit_yaw = value + return property(**locals()) + + @apply + def lower_limit_pitch(): + def fget( self ): + return self._lower_limit_pitch + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_pitch is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_pitch = rotational_range_measure(value) + else: + self._lower_limit_pitch = value + return property(**locals()) + + @apply + def upper_limit_pitch(): + def fget( self ): + return self._upper_limit_pitch + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_pitch is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_pitch = rotational_range_measure(value) + else: + self._upper_limit_pitch = value + return property(**locals()) + + @apply + def lower_limit_roll(): + def fget( self ): + return self._lower_limit_roll + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_roll is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_roll = rotational_range_measure(value) + else: + self._lower_limit_roll = value + return property(**locals()) + + @apply + def upper_limit_roll(): + def fget( self ): + return self._upper_limit_roll + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_roll is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_roll = rotational_range_measure(value) + else: + self._upper_limit_roll = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_yaw)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_yaw))) XOR (self.lower_limit_yaw < self.upper_limit_yaw)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_pitch)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_pitch))) XOR (self.lower_limit_pitch < self.upper_limit_pitch)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_roll)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_roll))) XOR (self.lower_limit_roll < self.upper_limit_roll)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY applied_group_assignment # +#################### +class applied_group_assignment(group_assignment): + '''Entity applied_group_assignment definition. + + :param items + :type items:SET(1,None,'group_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_group , items, ): + group_assignment.__init__(self , inherited0__assigned_group , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'group_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (self.self.role.self.name == 'exclusiveness')) or item_correlation(self.self.items,['ACTION'])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not (self.self.role.self.name == 'simultaneity')) or item_correlation(self.self.items,['ACTION'])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not (self.self.role.self.name == 'specification category member')) or item_correlation(self.self.items,['PRODUCT_CONCEPT_FEATURE'])) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (self.self.role.self.name == 'group membership')) or item_correlation(self.self.items,['GEOMETRIC_REPRESENTATION_ITEM','SHAPE_ASPECT'])) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((( not (self.self.role.self.name == 'group membership')) or (SIZEOF(self.self.items) == SIZEOF(None))) or (SIZEOF(self.self.items) == SIZEOF(None))) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY configuration_item # +#################### +class configuration_item(BaseEntityClass): + '''Entity configuration_item definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + + :param item_concept + :type item_concept:product_concept + + :param purpose + :type purpose:label + ''' + def __init__( self , id,name,description,item_concept,purpose, ): + self.id = id + self.name = name + self.description = description + self.item_concept = item_concept + self.purpose = purpose + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def item_concept(): + def fget( self ): + return self._item_concept + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_concept is mantatory and can not be set to None') + if not check_type(value,product_concept): + self._item_concept = product_concept(value) + else: + self._item_concept = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._purpose = label(value) + else: + self._purpose = value + else: + self._purpose = value + return property(**locals()) + +#################### + # ENTITY configurable_item # +#################### +class configurable_item(configuration_item): + '''Entity configurable_item definition. + + :param item_concept_feature + :type item_concept_feature:SET(1,None,'product_concept_feature_association', scope = schema_scope) + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__item_concept , inherited4__purpose , item_concept_feature, ): + configuration_item.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__item_concept , inherited4__purpose , ) + self.item_concept_feature = item_concept_feature + + @apply + def item_concept_feature(): + def fget( self ): + return self._item_concept_feature + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_concept_feature is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'product_concept_feature_association', scope = schema_scope)): + self._item_concept_feature = SET(value) + else: + self._item_concept_feature = value + return property(**locals()) + +#################### + # ENTITY global_uncertainty_assigned_context # +#################### +class global_uncertainty_assigned_context(representation_context): + '''Entity global_uncertainty_assigned_context definition. + + :param uncertainty + :type uncertainty:SET(1,None,'uncertainty_measure_with_unit', scope = schema_scope) + ''' + def __init__( self , inherited0__context_identifier , inherited1__context_type , uncertainty, ): + representation_context.__init__(self , inherited0__context_identifier , inherited1__context_type , ) + self.uncertainty = uncertainty + + @apply + def uncertainty(): + def fget( self ): + return self._uncertainty + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument uncertainty is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'uncertainty_measure_with_unit', scope = schema_scope)): + self._uncertainty = SET(value) + else: + self._uncertainty = value + return property(**locals()) + +#################### + # ENTITY pre_defined_surface_condition_symbol # +#################### +class pre_defined_surface_condition_symbol(pre_defined_symbol): + '''Entity pre_defined_surface_condition_symbol definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_symbol.__init__(self , inherited0__name , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['000','010','020','030','040','050','060','070','001','011','021','031','041','051','061','071','100','110','120','130','140','150','160','170','101','111','121','131','141','151','161','171','200','210','220','230','240','250','260','270','201','211','221','231','241','251','261','271']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ngon_closed_profile # +#################### +class ngon_closed_profile(shape_aspect): + '''Entity ngon_closed_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + +#################### + # ENTITY runout_zone_orientation # +#################### +class runout_zone_orientation(BaseEntityClass): + '''Entity runout_zone_orientation definition. + + :param angle + :type angle:measure_with_unit + ''' + def __init__( self , angle, ): + self.angle = angle + + @apply + def angle(): + def fget( self ): + return self._angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument angle is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._angle = measure_with_unit(value) + else: + self._angle = value + return property(**locals()) + +#################### + # ENTITY runout_zone_orientation_reference_direction # +#################### +class runout_zone_orientation_reference_direction(runout_zone_orientation): + '''Entity runout_zone_orientation_reference_direction definition. + + :param orientation_defining_relationship + :type orientation_defining_relationship:shape_aspect_relationship + ''' + def __init__( self , inherited0__angle , orientation_defining_relationship, ): + runout_zone_orientation.__init__(self , inherited0__angle , ) + self.orientation_defining_relationship = orientation_defining_relationship + + @apply + def orientation_defining_relationship(): + def fget( self ): + return self._orientation_defining_relationship + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation_defining_relationship is mantatory and can not be set to None') + if not check_type(value,shape_aspect_relationship): + self._orientation_defining_relationship = shape_aspect_relationship(value) + else: + self._orientation_defining_relationship = value + return property(**locals()) + +#################### + # ENTITY text_style_with_box_characteristics # +#################### +class text_style_with_box_characteristics(text_style): + '''Entity text_style_with_box_characteristics definition. + + :param characteristics + :type characteristics:SET(1,4,'box_characteristic_select', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__character_appearance , characteristics, ): + text_style.__init__(self , inherited0__name , inherited1__character_appearance , ) + self.characteristics = characteristics + + @apply + def characteristics(): + def fget( self ): + return self._characteristics + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument characteristics is mantatory and can not be set to None') + if not check_type(value,SET(1,4,'box_characteristic_select', scope = schema_scope)): + self._characteristics = SET(value) + else: + self._characteristics = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY action_resource_type # +#################### +class action_resource_type(BaseEntityClass): + '''Entity action_resource_type definition. + + :param name + :type name:label + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY chamfer_offset # +#################### +class chamfer_offset(shape_aspect): + '''Entity chamfer_offset definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (self.self.description == ['first offset','second offset']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.description != 'first offset') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'second offset') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) >= 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((self.self.description != 'first offset') or (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((self.self.description != 'second offset') or (SIZEOF(None) == 1)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + +#################### + # ENTITY connected_face_sub_set # +#################### +class connected_face_sub_set(connected_face_set): + '''Entity connected_face_sub_set definition. + + :param parent_face_set + :type parent_face_set:connected_face_set + ''' + def __init__( self , inherited0__name , inherited1__cfs_faces , parent_face_set, ): + connected_face_set.__init__(self , inherited0__name , inherited1__cfs_faces , ) + self.parent_face_set = parent_face_set + + @apply + def parent_face_set(): + def fget( self ): + return self._parent_face_set + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parent_face_set is mantatory and can not be set to None') + if not check_type(value,connected_face_set): + self._parent_face_set = connected_face_set(value) + else: + self._parent_face_set = value + return property(**locals()) + +#################### + # ENTITY organization_relationship # +#################### +class organization_relationship(BaseEntityClass): + '''Entity organization_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_organization + :type relating_organization:organization + + :param related_organization + :type related_organization:organization + ''' + def __init__( self , name,description,relating_organization,related_organization, ): + self.name = name + self.description = description + self.relating_organization = relating_organization + self.related_organization = related_organization + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_organization(): + def fget( self ): + return self._relating_organization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_organization is mantatory and can not be set to None') + if not check_type(value,organization): + self._relating_organization = organization(value) + else: + self._relating_organization = value + return property(**locals()) + + @apply + def related_organization(): + def fget( self ): + return self._related_organization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_organization is mantatory and can not be set to None') + if not check_type(value,organization): + self._related_organization = organization(value) + else: + self._related_organization = value + return property(**locals()) + +#################### + # ENTITY substring_expression # +#################### +class substring_expression(string_expression,multiple_arity_generic_expression): + '''Entity substring_expression definition. + + :param operand + :type operand:generic_expression + + :param index1 + :type index1:generic_expression + + :param index2 + :type index2:generic_expression + ''' + def __init__( self , inherited0__operands , ): + string_expression.__init__(self , ) + multiple_arity_generic_expression.__init__(self , inherited0__operands , ) + + @apply + def operand(): + def fget( self ): + attribute_eval = self.self.multiple_arity_generic_expression.self.operands[1] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument operand is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def index1(): + def fget( self ): + attribute_eval = self.self.multiple_arity_generic_expression.self.operands[2] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument index1 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def index2(): + def fget( self ): + attribute_eval = self.self.multiple_arity_generic_expression.self.operands[3] + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument index2 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.operand)) and ('AUTOMOTIVE_DESIGN.NUMERIC_EXPRESSION' == TYPEOF(self.index1))) and ('AUTOMOTIVE_DESIGN.NUMERIC_EXPRESSION' == TYPEOF(self.index2))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(self.self.multiple_arity_generic_expression.self.operands) == 3) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = is_int_expr(self.index1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = is_int_expr(self.index2) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY light_source_ambient # +#################### +class light_source_ambient(light_source): + '''Entity light_source_ambient definition. + ''' + def __init__( self , inherited0__name , inherited1__light_colour , ): + light_source.__init__(self , inherited0__name , inherited1__light_colour , ) + +#################### + # ENTITY named_unit_variable # +#################### +class named_unit_variable(named_unit,variable_semantics): + '''Entity named_unit_variable definition. + + :param associated_variable_environment + :type associated_variable_environment:environment + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + variable_semantics.__init__(self , ) + + @apply + def associated_variable_environment(): + def fget( self ): + return self._associated_variable_environment + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument associated_variable_environment is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY parabola # +#################### +class parabola(conic): + '''Entity parabola definition. + + :param focal_dist + :type focal_dist:length_measure + ''' + def __init__( self , inherited0__name , inherited1__position , focal_dist, ): + conic.__init__(self , inherited0__name , inherited1__position , ) + self.focal_dist = focal_dist + + @apply + def focal_dist(): + def fget( self ): + return self._focal_dist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument focal_dist is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._focal_dist = length_measure(value) + else: + self._focal_dist = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.focal_dist != 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY rectangular_composite_surface # +#################### +class rectangular_composite_surface(bounded_surface): + '''Entity rectangular_composite_surface definition. + + :param segments + :type segments:LIST(1,None,LIST(1,None,'surface_patch', scope = schema_scope)) + + :param n_u + :type n_u:INTEGER + + :param n_v + :type n_v:INTEGER + ''' + def __init__( self , inherited0__name , segments, ): + bounded_surface.__init__(self , inherited0__name , ) + self.segments = segments + + @apply + def segments(): + def fget( self ): + return self._segments + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument segments is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,LIST(1,None,'surface_patch', scope = schema_scope))): + self._segments = LIST(value) + else: + self._segments = value + return property(**locals()) + + @apply + def n_u(): + def fget( self ): + attribute_eval = SIZEOF(self.segments) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument n_u is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def n_v(): + def fget( self ): + attribute_eval = SIZEOF(self.segments[1]) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument n_v is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = constraints_rectangular_composite_surface(self) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY externally_defined_text_font # +#################### +class externally_defined_text_font(externally_defined_item): + '''Entity externally_defined_text_font definition. + ''' + def __init__( self , inherited0__item_id , inherited1__source , ): + externally_defined_item.__init__(self , inherited0__item_id , inherited1__source , ) + +#################### + # ENTITY face # +#################### +class face(topological_representation_item): + '''Entity face definition. + + :param bounds + :type bounds:SET(1,None,'face_bound', scope = schema_scope) + ''' + def __init__( self , inherited0__name , bounds, ): + topological_representation_item.__init__(self , inherited0__name , ) + self.bounds = bounds + + @apply + def bounds(): + def fget( self ): + return self._bounds + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bounds is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'face_bound', scope = schema_scope)): + self._bounds = SET(value) + else: + self._bounds = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not mixed_loop_type_set(list_to_set(list_face_loops(self)))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY subface # +#################### +class subface(face): + '''Entity subface definition. + + :param parent_face + :type parent_face:face + ''' + def __init__( self , inherited0__name , inherited1__bounds , parent_face, ): + face.__init__(self , inherited0__name , inherited1__bounds , ) + self.parent_face = parent_face + + @apply + def parent_face(): + def fget( self ): + return self._parent_face + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parent_face is mantatory and can not be set to None') + if not check_type(value,face): + self._parent_face = face(value) + else: + self._parent_face = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not mixed_loop_type_set(list_to_set(list_face_loops(self)) + list_to_set(list_face_loops(self.parent_face)))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY flatness_tolerance # +#################### +class flatness_tolerance(geometric_tolerance): + '''Entity flatness_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + def wr1(self): + eval_wr1_wr = ( not (('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE') == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY pre_defined_text_font # +#################### +class pre_defined_text_font(pre_defined_item): + '''Entity pre_defined_text_font definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY draughting_pre_defined_text_font # +#################### +class draughting_pre_defined_text_font(pre_defined_text_font): + '''Entity draughting_pre_defined_text_font definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_text_font.__init__(self , inherited0__name , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['ISO 3098']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY externally_defined_symbol # +#################### +class externally_defined_symbol(externally_defined_item): + '''Entity externally_defined_symbol definition. + ''' + def __init__( self , inherited0__item_id , inherited1__source , ): + externally_defined_item.__init__(self , inherited0__item_id , inherited1__source , ) + +#################### + # ENTITY planar_curve_pair # +#################### +class planar_curve_pair(kinematic_pair): + '''Entity planar_curve_pair definition. + + :param curve_1 + :type curve_1:curve + + :param curve_2 + :type curve_2:curve + + :param orientation + :type orientation:BOOLEAN + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , curve_1,curve_2,orientation, ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + self.curve_1 = curve_1 + self.curve_2 = curve_2 + self.orientation = orientation + + @apply + def curve_1(): + def fget( self ): + return self._curve_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curve_1 is mantatory and can not be set to None') + if not check_type(value,curve): + self._curve_1 = curve(value) + else: + self._curve_1 = value + return property(**locals()) + + @apply + def curve_2(): + def fget( self ): + return self._curve_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curve_2 is mantatory and can not be set to None') + if not check_type(value,curve): + self._curve_2 = curve(value) + else: + self._curve_2 = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = frame_associated_to_background(self.self.kinematic_pair.self.pair_placement_in_first_link_context,self.curve_1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = frame_associated_to_background(self.self.kinematic_pair.self.pair_placement_in_second_link_context,self.curve_2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY amount_of_substance_unit # +#################### +class amount_of_substance_unit(named_unit): + '''Entity amount_of_substance_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 0) and (self.self.named_unit.self.dimensions.self.mass_exponent == 0)) and (self.self.named_unit.self.dimensions.self.time_exponent == 0)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 0)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 0)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 1)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY one_direction_repeat_factor # +#################### +class one_direction_repeat_factor(geometric_representation_item): + '''Entity one_direction_repeat_factor definition. + + :param repeat_factor + :type repeat_factor:vector + ''' + def __init__( self , inherited0__name , repeat_factor, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.repeat_factor = repeat_factor + + @apply + def repeat_factor(): + def fget( self ): + return self._repeat_factor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument repeat_factor is mantatory and can not be set to None') + if not check_type(value,vector): + self._repeat_factor = vector(value) + else: + self._repeat_factor = value + return property(**locals()) + +#################### + # ENTITY action_method # +#################### +class action_method(BaseEntityClass): + '''Entity action_method definition. + + :param name + :type name:label + + :param description + :type description:text + + :param consequence + :type consequence:text + + :param purpose + :type purpose:text + ''' + def __init__( self , name,description,consequence,purpose, ): + self.name = name + self.description = description + self.consequence = consequence + self.purpose = purpose + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def consequence(): + def fget( self ): + return self._consequence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument consequence is mantatory and can not be set to None') + if not check_type(value,text): + self._consequence = text(value) + else: + self._consequence = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument purpose is mantatory and can not be set to None') + if not check_type(value,text): + self._purpose = text(value) + else: + self._purpose = value + return property(**locals()) + +#################### + # ENTITY process_operation # +#################### +class process_operation(action_method): + '''Entity process_operation definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__consequence , inherited3__purpose , ): + action_method.__init__(self , inherited0__name , inherited1__description , inherited2__consequence , inherited3__purpose , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY unconstrained_pair # +#################### +class unconstrained_pair(kinematic_pair): + '''Entity unconstrained_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + +#################### + # ENTITY lot_effectivity # +#################### +class lot_effectivity(effectivity): + '''Entity lot_effectivity definition. + + :param effectivity_lot_id + :type effectivity_lot_id:identifier + + :param effectivity_lot_size + :type effectivity_lot_size:measure_with_unit + ''' + def __init__( self , inherited0__id , effectivity_lot_id,effectivity_lot_size, ): + effectivity.__init__(self , inherited0__id , ) + self.effectivity_lot_id = effectivity_lot_id + self.effectivity_lot_size = effectivity_lot_size + + @apply + def effectivity_lot_id(): + def fget( self ): + return self._effectivity_lot_id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument effectivity_lot_id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._effectivity_lot_id = identifier(value) + else: + self._effectivity_lot_id = value + return property(**locals()) + + @apply + def effectivity_lot_size(): + def fget( self ): + return self._effectivity_lot_size + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument effectivity_lot_size is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._effectivity_lot_size = measure_with_unit(value) + else: + self._effectivity_lot_size = value + return property(**locals()) + +#################### + # ENTITY surface_of_linear_extrusion # +#################### +class surface_of_linear_extrusion(swept_surface): + '''Entity surface_of_linear_extrusion definition. + + :param extrusion_axis + :type extrusion_axis:vector + ''' + def __init__( self , inherited0__name , inherited1__swept_curve , extrusion_axis, ): + swept_surface.__init__(self , inherited0__name , inherited1__swept_curve , ) + self.extrusion_axis = extrusion_axis + + @apply + def extrusion_axis(): + def fget( self ): + return self._extrusion_axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extrusion_axis is mantatory and can not be set to None') + if not check_type(value,vector): + self._extrusion_axis = vector(value) + else: + self._extrusion_axis = value + return property(**locals()) + +#################### + # ENTITY environment # +#################### +class environment(BaseEntityClass): + '''Entity environment definition. + + :param syntactic_representation + :type syntactic_representation:generic_variable + + :param semantics + :type semantics:variable_semantics + ''' + def __init__( self , syntactic_representation,semantics, ): + self.syntactic_representation = syntactic_representation + self.semantics = semantics + + @apply + def syntactic_representation(): + def fget( self ): + return self._syntactic_representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument syntactic_representation is mantatory and can not be set to None') + if not check_type(value,generic_variable): + self._syntactic_representation = generic_variable(value) + else: + self._syntactic_representation = value + return property(**locals()) + + @apply + def semantics(): + def fget( self ): + return self._semantics + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semantics is mantatory and can not be set to None') + if not check_type(value,variable_semantics): + self._semantics = variable_semantics(value) + else: + self._semantics = value + return property(**locals()) + +#################### + # ENTITY geometric_tolerance_relationship # +#################### +class geometric_tolerance_relationship(BaseEntityClass): + '''Entity geometric_tolerance_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_geometric_tolerance + :type relating_geometric_tolerance:geometric_tolerance + + :param related_geometric_tolerance + :type related_geometric_tolerance:geometric_tolerance + ''' + def __init__( self , name,description,relating_geometric_tolerance,related_geometric_tolerance, ): + self.name = name + self.description = description + self.relating_geometric_tolerance = relating_geometric_tolerance + self.related_geometric_tolerance = related_geometric_tolerance + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def relating_geometric_tolerance(): + def fget( self ): + return self._relating_geometric_tolerance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_geometric_tolerance is mantatory and can not be set to None') + if not check_type(value,geometric_tolerance): + self._relating_geometric_tolerance = geometric_tolerance(value) + else: + self._relating_geometric_tolerance = value + return property(**locals()) + + @apply + def related_geometric_tolerance(): + def fget( self ): + return self._related_geometric_tolerance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_geometric_tolerance is mantatory and can not be set to None') + if not check_type(value,geometric_tolerance): + self._related_geometric_tolerance = geometric_tolerance(value) + else: + self._related_geometric_tolerance = value + return property(**locals()) + +#################### + # ENTITY shape_defining_relationship # +#################### +class shape_defining_relationship(shape_aspect_relationship): + '''Entity shape_defining_relationship definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ): + shape_aspect_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + def wr1(self): + eval_wr1_wr = ((self.self.shape_aspect_relationship.self.description != 'profile usage') or (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'RECTANGULAR_CLOSED_PROFILE','AUTOMOTIVE_DESIGN.' + 'CIRCULAR_CLOSED_PROFILE','AUTOMOTIVE_DESIGN.' + 'NGON_CLOSED_PROFILE','AUTOMOTIVE_DESIGN.' + 'CLOSED_PATH_PROFILE','AUTOMOTIVE_DESIGN.' + 'OPEN_PATH_PROFILE','AUTOMOTIVE_DESIGN.' + 'PARTIAL_CIRCULAR_PROFILE','AUTOMOTIVE_DESIGN.' + 'ROUNDED_U_PROFILE','AUTOMOTIVE_DESIGN.' + 'SQUARE_U_PROFILE','AUTOMOTIVE_DESIGN.' + 'TEE_PROFILE','AUTOMOTIVE_DESIGN.' + 'VEE_PROFILE'] * TYPEOF(self.self.shape_aspect_relationship.self.relating_shape_aspect)) == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((self.self.shape_aspect_relationship.self.description != 'path feature component usage') or (('AUTOMOTIVE_DESIGN.' + 'PATH_FEATURE_COMPONENT') == TYPEOF(self.self.shape_aspect_relationship.self.relating_shape_aspect))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY contract_assignment # +#################### +class contract_assignment(BaseEntityClass): + '''Entity contract_assignment definition. + + :param assigned_contract + :type assigned_contract:contract + + :param role + :type role:object_role + ''' + def __init__( self , assigned_contract, ): + self.assigned_contract = assigned_contract + + @apply + def assigned_contract(): + def fget( self ): + return self._assigned_contract + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_contract is mantatory and can not be set to None') + if not check_type(value,contract): + self._assigned_contract = contract(value) + else: + self._assigned_contract = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_contract_assignment # +#################### +class applied_contract_assignment(contract_assignment): + '''Entity applied_contract_assignment definition. + + :param items + :type items:SET(1,None,'contract_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_contract , items, ): + contract_assignment.__init__(self , inherited0__assigned_contract , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'contract_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY shell_based_surface_model # +#################### +class shell_based_surface_model(geometric_representation_item): + '''Entity shell_based_surface_model definition. + + :param sbsm_boundary + :type sbsm_boundary:SET(1,None,'shell', scope = schema_scope) + ''' + def __init__( self , inherited0__name , sbsm_boundary, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.sbsm_boundary = sbsm_boundary + + @apply + def sbsm_boundary(): + def fget( self ): + return self._sbsm_boundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sbsm_boundary is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'shell', scope = schema_scope)): + self._sbsm_boundary = SET(value) + else: + self._sbsm_boundary = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = constraints_geometry_shell_based_surface_model(self) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY uniform_curve # +#################### +class uniform_curve(b_spline_curve): + '''Entity uniform_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , ): + b_spline_curve.__init__(self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , ) + +#################### + # ENTITY bezier_curve # +#################### +class bezier_curve(b_spline_curve): + '''Entity bezier_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , ): + b_spline_curve.__init__(self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , ) + +#################### + # ENTITY loop # +#################### +class loop(topological_representation_item): + '''Entity loop definition. + ''' + def __init__( self , inherited0__name , ): + topological_representation_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY edge_loop # +#################### +class edge_loop(loop,path): + '''Entity edge_loop definition. + + :param ne + :type ne:INTEGER + ''' + def __init__( self , inherited0__name , inherited1__name , inherited2__edge_list , ): + loop.__init__(self , inherited0__name , ) + path.__init__(self , inherited1__name , inherited2__edge_list , ) + + @apply + def ne(): + def fget( self ): + attribute_eval = SIZEOF(self.self.path.self.edge_list) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ne is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.path.self.edge_list[1].self.edge_start == self.self.path.self.edge_list[self.ne].self.edge_end) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY kinematic_analysis_consistency # +#################### +class kinematic_analysis_consistency(BaseEntityClass): + '''Entity kinematic_analysis_consistency definition. + + :param control + :type control:kinematic_control + + :param result + :type result:kinematic_analysis_result + ''' + def __init__( self , control,result, ): + self.control = control + self.result = result + + @apply + def control(): + def fget( self ): + return self._control + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument control is mantatory and can not be set to None') + if not check_type(value,kinematic_control): + self._control = kinematic_control(value) + else: + self._control = value + return property(**locals()) + + @apply + def result(): + def fget( self ): + return self._result + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument result is mantatory and can not be set to None') + if not check_type(value,kinematic_analysis_result): + self._result = kinematic_analysis_result(value) + else: + self._result = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.control.self.controlled_mechanism == self.result.self.analysed_mechanism) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY rack_and_pinion_pair # +#################### +class rack_and_pinion_pair(kinematic_pair): + '''Entity rack_and_pinion_pair definition. + + :param pinion_radius + :type pinion_radius:length_measure + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , pinion_radius, ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + self.pinion_radius = pinion_radius + + @apply + def pinion_radius(): + def fget( self ): + return self._pinion_radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pinion_radius is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._pinion_radius = length_measure(value) + else: + self._pinion_radius = value + return property(**locals()) + +#################### + # ENTITY date # +#################### +class date(BaseEntityClass): + '''Entity date definition. + + :param year_component + :type year_component:year_number + ''' + def __init__( self , year_component, ): + self.year_component = year_component + + @apply + def year_component(): + def fget( self ): + return self._year_component + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument year_component is mantatory and can not be set to None') + if not check_type(value,year_number): + self._year_component = year_number(value) + else: + self._year_component = value + return property(**locals()) + +#################### + # ENTITY calendar_date # +#################### +class calendar_date(date): + '''Entity calendar_date definition. + + :param day_component + :type day_component:day_in_month_number + + :param month_component + :type month_component:month_in_year_number + ''' + def __init__( self , inherited0__year_component , day_component,month_component, ): + date.__init__(self , inherited0__year_component , ) + self.day_component = day_component + self.month_component = month_component + + @apply + def day_component(): + def fget( self ): + return self._day_component + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument day_component is mantatory and can not be set to None') + if not check_type(value,day_in_month_number): + self._day_component = day_in_month_number(value) + else: + self._day_component = value + return property(**locals()) + + @apply + def month_component(): + def fget( self ): + return self._month_component + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument month_component is mantatory and can not be set to None') + if not check_type(value,month_in_year_number): + self._month_component = month_in_year_number(value) + else: + self._month_component = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = valid_calendar_date(self) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY concat_expression # +#################### +class concat_expression(string_expression,multiple_arity_generic_expression): + '''Entity concat_expression definition. + + :param multiple_arity_generic_expression_operands + :type multiple_arity_generic_expression_operands:LIST(2,None,'string_expression', scope = schema_scope) + ''' + def __init__( self , inherited0__operands , multiple_arity_generic_expression_operands, ): + string_expression.__init__(self , ) + multiple_arity_generic_expression.__init__(self , inherited0__operands , ) + self.multiple_arity_generic_expression_operands = multiple_arity_generic_expression_operands + + @apply + def multiple_arity_generic_expression_operands(): + def fget( self ): + return self._multiple_arity_generic_expression_operands + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument multiple_arity_generic_expression_operands is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'string_expression', scope = schema_scope)): + self._multiple_arity_generic_expression_operands = LIST(value) + else: + self._multiple_arity_generic_expression_operands = value + return property(**locals()) + +#################### + # ENTITY dimension_curve_terminator # +#################### +class dimension_curve_terminator(terminator_symbol): + '''Entity dimension_curve_terminator definition. + + :param role + :type role:dimension_extent_usage + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , inherited4__annotated_curve , role, ): + terminator_symbol.__init__(self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , inherited4__annotated_curve , ) + self.role = role + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,dimension_extent_usage): + self._role = dimension_extent_usage(value) + else: + self._role = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.DIMENSION_CURVE' == TYPEOF(self.self.terminator_symbol.self.annotated_curve)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY externally_defined_curve_font # +#################### +class externally_defined_curve_font(externally_defined_item): + '''Entity externally_defined_curve_font definition. + ''' + def __init__( self , inherited0__item_id , inherited1__source , ): + externally_defined_item.__init__(self , inherited0__item_id , inherited1__source , ) + +#################### + # ENTITY toroidal_surface # +#################### +class toroidal_surface(elementary_surface): + '''Entity toroidal_surface definition. + + :param major_radius + :type major_radius:positive_length_measure + + :param minor_radius + :type minor_radius:positive_length_measure + ''' + def __init__( self , inherited0__name , inherited1__position , major_radius,minor_radius, ): + elementary_surface.__init__(self , inherited0__name , inherited1__position , ) + self.major_radius = major_radius + self.minor_radius = minor_radius + + @apply + def major_radius(): + def fget( self ): + return self._major_radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument major_radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._major_radius = positive_length_measure(value) + else: + self._major_radius = value + return property(**locals()) + + @apply + def minor_radius(): + def fget( self ): + return self._minor_radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument minor_radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._minor_radius = positive_length_measure(value) + else: + self._minor_radius = value + return property(**locals()) + +#################### + # ENTITY promissory_usage_occurrence # +#################### +class promissory_usage_occurrence(assembly_component_usage): + '''Entity promissory_usage_occurrence definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , inherited5__reference_designator , ): + assembly_component_usage.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , inherited5__reference_designator , ) + +#################### + # ENTITY kinematic_frame_background_representation # +#################### +class kinematic_frame_background_representation(representation): + '''Entity kinematic_frame_background_representation definition. + + :param representation_items + :type representation_items:SET(1,None,'kinematic_frame_background', scope = schema_scope) + + :param representation_context_of_items + :type representation_context_of_items:geometric_representation_context + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , representation_items,representation_context_of_items, ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + self.representation_items = representation_items + self.representation_context_of_items = representation_context_of_items + + @apply + def representation_items(): + def fget( self ): + return self._representation_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'kinematic_frame_background', scope = schema_scope)): + self._representation_items = SET(value) + else: + self._representation_items = value + return property(**locals()) + + @apply + def representation_context_of_items(): + def fget( self ): + return self._representation_context_of_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_context_of_items is mantatory and can not be set to None') + if not check_type(value,geometric_representation_context): + self._representation_context_of_items = geometric_representation_context(value) + else: + self._representation_context_of_items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.representation.self.context_of_items.self.geometric_representation_context.self.coordinate_space_dimension == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_concept_feature # +#################### +class product_concept_feature(BaseEntityClass): + '''Entity product_concept_feature definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , id,name,description, ): + self.id = id + self.name = name + self.description = description + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY package_product_concept_feature # +#################### +class package_product_concept_feature(product_concept_feature): + '''Entity package_product_concept_feature definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , ): + product_concept_feature.__init__(self , inherited0__id , inherited1__name , inherited2__description , ) + def wr1(self): + eval_wr1_wr = ( not (('AUTOMOTIVE_DESIGN.' + 'CONDITIONAL_CONCEPT_FEATURE') == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY approval_assignment # +#################### +class approval_assignment(BaseEntityClass): + '''Entity approval_assignment definition. + + :param assigned_approval + :type assigned_approval:approval + + :param role + :type role:object_role + ''' + def __init__( self , assigned_approval, ): + self.assigned_approval = assigned_approval + + @apply + def assigned_approval(): + def fget( self ): + return self._assigned_approval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_approval is mantatory and can not be set to None') + if not check_type(value,approval): + self._assigned_approval = approval(value) + else: + self._assigned_approval = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY rotation_about_direction # +#################### +class rotation_about_direction(BaseEntityClass): + '''Entity rotation_about_direction definition. + + :param direction_of_axis + :type direction_of_axis:direction + + :param rotation_angle + :type rotation_angle:plane_angle_measure + ''' + def __init__( self , direction_of_axis,rotation_angle, ): + self.direction_of_axis = direction_of_axis + self.rotation_angle = rotation_angle + + @apply + def direction_of_axis(): + def fget( self ): + return self._direction_of_axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument direction_of_axis is mantatory and can not be set to None') + if not check_type(value,direction): + self._direction_of_axis = direction(value) + else: + self._direction_of_axis = value + return property(**locals()) + + @apply + def rotation_angle(): + def fget( self ): + return self._rotation_angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rotation_angle is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._rotation_angle = plane_angle_measure(value) + else: + self._rotation_angle = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.direction_of_axis.self.direction_ratios) == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY character_glyph_symbol # +#################### +class character_glyph_symbol(generic_character_glyph_symbol): + '''Entity character_glyph_symbol definition. + + :param character_box + :type character_box:planar_extent + + :param baseline_ratio + :type baseline_ratio:ratio_measure + + :param box_height + :type box_height:length_measure + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , character_box,baseline_ratio, ): + generic_character_glyph_symbol.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + self.character_box = character_box + self.baseline_ratio = baseline_ratio + + @apply + def character_box(): + def fget( self ): + return self._character_box + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument character_box is mantatory and can not be set to None') + if not check_type(value,planar_extent): + self._character_box = planar_extent(value) + else: + self._character_box = value + return property(**locals()) + + @apply + def baseline_ratio(): + def fget( self ): + return self._baseline_ratio + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument baseline_ratio is mantatory and can not be set to None') + if not check_type(value,ratio_measure): + self._baseline_ratio = ratio_measure(value) + else: + self._baseline_ratio = value + return property(**locals()) + + @apply + def box_height(): + def fget( self ): + attribute_eval = self.character_box.self.size_in_y + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument box_height is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((0 <= self.baseline_ratio) and (self.baseline_ratio <= 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = item_in_context(self.self.character_box,self.self.representation.self.context_of_items) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ('AUTOMOTIVE_DESIGN.POSITIVE_LENGTH_MEASURE' == TYPEOF(self.self.box_height)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY configuration_interpolation # +#################### +class configuration_interpolation(BaseEntityClass): + '''Entity configuration_interpolation definition. + + :param previous_configuration_definition + :type previous_configuration_definition:configuration_definition + + :param next_configuration_definition + :type next_configuration_definition:configuration_definition + + :param interpolation + :type interpolation:interpolation_type + ''' + def __init__( self , previous_configuration_definition,next_configuration_definition,interpolation, ): + self.previous_configuration_definition = previous_configuration_definition + self.next_configuration_definition = next_configuration_definition + self.interpolation = interpolation + + @apply + def previous_configuration_definition(): + def fget( self ): + return self._previous_configuration_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument previous_configuration_definition is mantatory and can not be set to None') + if not check_type(value,configuration_definition): + self._previous_configuration_definition = configuration_definition(value) + else: + self._previous_configuration_definition = value + return property(**locals()) + + @apply + def next_configuration_definition(): + def fget( self ): + return self._next_configuration_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument next_configuration_definition is mantatory and can not be set to None') + if not check_type(value,configuration_definition): + self._next_configuration_definition = configuration_definition(value) + else: + self._next_configuration_definition = value + return property(**locals()) + + @apply + def interpolation(): + def fget( self ): + return self._interpolation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument interpolation is mantatory and can not be set to None') + if not check_type(value,interpolation_type): + self._interpolation = interpolation_type(value) + else: + self._interpolation = value + return property(**locals()) + +#################### + # ENTITY curve_style_font # +#################### +class curve_style_font(founded_item): + '''Entity curve_style_font definition. + + :param name + :type name:label + + :param pattern_list + :type pattern_list:LIST(1,None,'curve_style_font_pattern', scope = schema_scope) + ''' + def __init__( self , name,pattern_list, ): + founded_item.__init__(self , ) + self.name = name + self.pattern_list = pattern_list + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def pattern_list(): + def fget( self ): + return self._pattern_list + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pattern_list is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'curve_style_font_pattern', scope = schema_scope)): + self._pattern_list = LIST(value) + else: + self._pattern_list = value + return property(**locals()) + +#################### + # ENTITY kinematic_structure # +#################### +class kinematic_structure(BaseEntityClass): + '''Entity kinematic_structure definition. + + :param joints + :type joints:SET(1,None,'kinematic_joint', scope = schema_scope) + ''' + def __init__( self , joints, ): + self.joints = joints + + @apply + def joints(): + def fget( self ): + return self._joints + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument joints is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'kinematic_joint', scope = schema_scope)): + self._joints = SET(value) + else: + self._joints = value + return property(**locals()) + +#################### + # ENTITY rolling_curve_pair # +#################### +class rolling_curve_pair(planar_curve_pair): + '''Entity rolling_curve_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__curve_1 , inherited6__curve_2 , inherited7__orientation , ): + planar_curve_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__curve_1 , inherited6__curve_2 , inherited7__orientation , ) + +#################### + # ENTITY value_representation_item # +#################### +class value_representation_item(representation_item): + '''Entity value_representation_item definition. + + :param value_component + :type value_component:measure_value + ''' + def __init__( self , inherited0__name , value_component, ): + representation_item.__init__(self , inherited0__name , ) + self.value_component = value_component + + @apply + def value_component(): + def fget( self ): + return self._value_component + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument value_component is mantatory and can not be set to None') + if not check_type(value,measure_value): + self._value_component = measure_value(value) + else: + self._value_component = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY circular_closed_profile # +#################### +class circular_closed_profile(shape_aspect): + '''Entity circular_closed_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY binary_numeric_expression # +#################### +class binary_numeric_expression(numeric_expression,binary_generic_expression): + '''Entity binary_numeric_expression definition. + + :param binary_generic_expression_operands + :type binary_generic_expression_operands:LIST(2,2,'numeric_expression', scope = schema_scope) + ''' + def __init__( self , inherited0__operands , binary_generic_expression_operands, ): + numeric_expression.__init__(self , ) + binary_generic_expression.__init__(self , inherited0__operands , ) + self.binary_generic_expression_operands = binary_generic_expression_operands + + @apply + def binary_generic_expression_operands(): + def fget( self ): + return self._binary_generic_expression_operands + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument binary_generic_expression_operands is mantatory and can not be set to None') + if not check_type(value,LIST(2,2,'numeric_expression', scope = schema_scope)): + self._binary_generic_expression_operands = LIST(value) + else: + self._binary_generic_expression_operands = value + return property(**locals()) + +#################### + # ENTITY minus_expression # +#################### +class minus_expression(binary_numeric_expression): + '''Entity minus_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + binary_numeric_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY position_tolerance # +#################### +class position_tolerance(geometric_tolerance): + '''Entity position_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + def wr1(self): + eval_wr1_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE') == TYPEOF(self))) or (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) <= 3)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_definition_substitute # +#################### +class product_definition_substitute(BaseEntityClass): + '''Entity product_definition_substitute definition. + + :param description + :type description:text + + :param context_relationship + :type context_relationship:product_definition_relationship + + :param substitute_definition + :type substitute_definition:product_definition + + :param name + :type name:label + ''' + def __init__( self , description,context_relationship,substitute_definition, ): + self.description = description + self.context_relationship = context_relationship + self.substitute_definition = substitute_definition + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def context_relationship(): + def fget( self ): + return self._context_relationship + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument context_relationship is mantatory and can not be set to None') + if not check_type(value,product_definition_relationship): + self._context_relationship = product_definition_relationship(value) + else: + self._context_relationship = value + return property(**locals()) + + @apply + def substitute_definition(): + def fget( self ): + return self._substitute_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument substitute_definition is mantatory and can not be set to None') + if not check_type(value,product_definition): + self._substitute_definition = product_definition(value) + else: + self._substitute_definition = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.context_relationship.self.related_product_definition != self.substitute_definition) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY representation_map # +#################### +class representation_map(BaseEntityClass): + '''Entity representation_map definition. + + :param mapping_origin + :type mapping_origin:representation_item + + :param mapped_representation + :type mapped_representation:representation + + :param map_usage + :type map_usage:SET(1,None,'mapped_item', scope = schema_scope) + ''' + def __init__( self , mapping_origin,mapped_representation, ): + self.mapping_origin = mapping_origin + self.mapped_representation = mapped_representation + + @apply + def mapping_origin(): + def fget( self ): + return self._mapping_origin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapping_origin is mantatory and can not be set to None') + if not check_type(value,representation_item): + self._mapping_origin = representation_item(value) + else: + self._mapping_origin = value + return property(**locals()) + + @apply + def mapped_representation(): + def fget( self ): + return self._mapped_representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapped_representation is mantatory and can not be set to None') + if not check_type(value,representation): + self._mapped_representation = representation(value) + else: + self._mapped_representation = value + return property(**locals()) + + @apply + def map_usage(): + def fget( self ): + return self._map_usage + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument map_usage is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = item_in_context(self.self.mapping_origin,self.self.mapped_representation.self.context_of_items) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY symbol_representation_map # +#################### +class symbol_representation_map(representation_map): + '''Entity symbol_representation_map definition. + + :param representation_map_mapped_representation + :type representation_map_mapped_representation:symbol_representation + + :param representation_map_mapping_origin + :type representation_map_mapping_origin:axis2_placement + ''' + def __init__( self , inherited0__mapping_origin , inherited1__mapped_representation , representation_map_mapped_representation,representation_map_mapping_origin, ): + representation_map.__init__(self , inherited0__mapping_origin , inherited1__mapped_representation , ) + self.representation_map_mapped_representation = representation_map_mapped_representation + self.representation_map_mapping_origin = representation_map_mapping_origin + + @apply + def representation_map_mapped_representation(): + def fget( self ): + return self._representation_map_mapped_representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_map_mapped_representation is mantatory and can not be set to None') + if not check_type(value,symbol_representation): + self._representation_map_mapped_representation = symbol_representation(value) + else: + self._representation_map_mapped_representation = value + return property(**locals()) + + @apply + def representation_map_mapping_origin(): + def fget( self ): + return self._representation_map_mapping_origin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_map_mapping_origin is mantatory and can not be set to None') + if not check_type(value,axis2_placement): + self._representation_map_mapping_origin = axis2_placement(value) + else: + self._representation_map_mapping_origin = value + return property(**locals()) + +#################### + # ENTITY vector # +#################### +class vector(geometric_representation_item): + '''Entity vector definition. + + :param orientation + :type orientation:direction + + :param magnitude + :type magnitude:length_measure + ''' + def __init__( self , inherited0__name , orientation,magnitude, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.orientation = orientation + self.magnitude = magnitude + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,direction): + self._orientation = direction(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def magnitude(): + def fget( self ): + return self._magnitude + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument magnitude is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._magnitude = length_measure(value) + else: + self._magnitude = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.magnitude >= 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY annotation_text # +#################### +class annotation_text(mapped_item): + '''Entity annotation_text definition. + + :param mapped_item_mapping_target + :type mapped_item_mapping_target:axis2_placement + ''' + def __init__( self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , mapped_item_mapping_target, ): + mapped_item.__init__(self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , ) + self.mapped_item_mapping_target = mapped_item_mapping_target + + @apply + def mapped_item_mapping_target(): + def fget( self ): + return self._mapped_item_mapping_target + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapped_item_mapping_target is mantatory and can not be set to None') + if not check_type(value,axis2_placement): + self._mapped_item_mapping_target = axis2_placement(value) + else: + self._mapped_item_mapping_target = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.TEXT_STRING_REPRESENTATION' == TYPEOF(self.self.mapped_item.self.mapping_source.self.mapped_representation)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('AUTOMOTIVE_DESIGN.GEOMETRIC_REPRESENTATION_ITEM' == TYPEOF(self)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY pcurve # +#################### +class pcurve(curve): + '''Entity pcurve definition. + + :param basis_surface + :type basis_surface:surface + + :param reference_to_curve + :type reference_to_curve:definitional_representation + ''' + def __init__( self , inherited0__name , basis_surface,reference_to_curve, ): + curve.__init__(self , inherited0__name , ) + self.basis_surface = basis_surface + self.reference_to_curve = reference_to_curve + + @apply + def basis_surface(): + def fget( self ): + return self._basis_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._basis_surface = surface(value) + else: + self._basis_surface = value + return property(**locals()) + + @apply + def reference_to_curve(): + def fget( self ): + return self._reference_to_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reference_to_curve is mantatory and can not be set to None') + if not check_type(value,definitional_representation): + self._reference_to_curve = definitional_representation(value) + else: + self._reference_to_curve = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.reference_to_curve.self.representation.self.items) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('AUTOMOTIVE_DESIGN.CURVE' == TYPEOF(self.reference_to_curve.self.representation.self.items[1])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.reference_to_curve.self.representation.self.items[1].self.geometric_representation_item.self.dim == 2) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY bounded_pcurve # +#################### +class bounded_pcurve(pcurve,bounded_curve): + '''Entity bounded_pcurve definition. + ''' + def __init__( self , inherited0__name , inherited1__basis_surface , inherited2__reference_to_curve , inherited3__name , ): + pcurve.__init__(self , inherited0__name , inherited1__basis_surface , inherited2__reference_to_curve , ) + bounded_curve.__init__(self , inherited3__name , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.BOUNDED_CURVE' == TYPEOF(self.self.pcurve.self.reference_to_curve.self.items[1])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY intersection_curve # +#################### +class intersection_curve(surface_curve): + '''Entity intersection_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__curve_3d , inherited2__associated_geometry , inherited3__master_representation , ): + surface_curve.__init__(self , inherited0__name , inherited1__curve_3d , inherited2__associated_geometry , inherited3__master_representation , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.surface_curve.self.associated_geometry) == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (associated_surface(self.self.surface_curve.self.associated_geometry[1]) != associated_surface(self.self.surface_curve.self.associated_geometry[2])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY presentation_set # +#################### +class presentation_set(BaseEntityClass): + '''Entity presentation_set definition. + + :param areas + :type areas:SET(1,None,'area_in_set', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def areas(): + def fget( self ): + return self._areas + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument areas is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY trimmed_curve # +#################### +class trimmed_curve(bounded_curve): + '''Entity trimmed_curve definition. + + :param basis_curve + :type basis_curve:curve + + :param trim_1 + :type trim_1:SET(1,2,'trimming_select', scope = schema_scope) + + :param trim_2 + :type trim_2:SET(1,2,'trimming_select', scope = schema_scope) + + :param sense_agreement + :type sense_agreement:BOOLEAN + + :param master_representation + :type master_representation:trimming_preference + ''' + def __init__( self , inherited0__name , basis_curve,trim_1,trim_2,sense_agreement,master_representation, ): + bounded_curve.__init__(self , inherited0__name , ) + self.basis_curve = basis_curve + self.trim_1 = trim_1 + self.trim_2 = trim_2 + self.sense_agreement = sense_agreement + self.master_representation = master_representation + + @apply + def basis_curve(): + def fget( self ): + return self._basis_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_curve is mantatory and can not be set to None') + if not check_type(value,curve): + self._basis_curve = curve(value) + else: + self._basis_curve = value + return property(**locals()) + + @apply + def trim_1(): + def fget( self ): + return self._trim_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument trim_1 is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'trimming_select', scope = schema_scope)): + self._trim_1 = SET(value) + else: + self._trim_1 = value + return property(**locals()) + + @apply + def trim_2(): + def fget( self ): + return self._trim_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument trim_2 is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'trimming_select', scope = schema_scope)): + self._trim_2 = SET(value) + else: + self._trim_2 = value + return property(**locals()) + + @apply + def sense_agreement(): + def fget( self ): + return self._sense_agreement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sense_agreement is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._sense_agreement = BOOLEAN(value) + else: + self._sense_agreement = value + return property(**locals()) + + @apply + def master_representation(): + def fget( self ): + return self._master_representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument master_representation is mantatory and can not be set to None') + if not check_type(value,trimming_preference): + self._master_representation = trimming_preference(value) + else: + self._master_representation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((HIINDEX(self.trim_1) == 1) or (TYPEOF(self.trim_1[1]) != TYPEOF(self.trim_1[2]))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((HIINDEX(self.trim_2) == 1) or (TYPEOF(self.trim_2[1]) != TYPEOF(self.trim_2[2]))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY projection_directed_callout # +#################### +class projection_directed_callout(draughting_callout): + '''Entity projection_directed_callout definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(self.self.draughting_callout.self.contents) >= 2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ordinate_dimension # +#################### +class ordinate_dimension(projection_directed_callout): + '''Entity ordinate_dimension definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + projection_directed_callout.__init__(self , inherited0__name , inherited1__contents , ) + +#################### + # ENTITY perpendicular_to # +#################### +class perpendicular_to(derived_shape_aspect): + '''Entity perpendicular_to definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + derived_shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.derived_shape_aspect.self.deriving_relationships) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_definition_context # +#################### +class product_definition_context(application_context_element): + '''Entity product_definition_context definition. + + :param life_cycle_stage + :type life_cycle_stage:label + ''' + def __init__( self , inherited0__name , inherited1__frame_of_reference , life_cycle_stage, ): + application_context_element.__init__(self , inherited0__name , inherited1__frame_of_reference , ) + self.life_cycle_stage = life_cycle_stage + + @apply + def life_cycle_stage(): + def fget( self ): + return self._life_cycle_stage + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument life_cycle_stage is mantatory and can not be set to None') + if not check_type(value,label): + self._life_cycle_stage = label(value) + else: + self._life_cycle_stage = value + return property(**locals()) + +#################### + # ENTITY tan_function # +#################### +class tan_function(unary_function_call): + '''Entity tan_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY geometric_alignment # +#################### +class geometric_alignment(derived_shape_aspect): + '''Entity geometric_alignment definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + derived_shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.derived_shape_aspect.self.deriving_relationships) > 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY geometric_intersection # +#################### +class geometric_intersection(derived_shape_aspect): + '''Entity geometric_intersection definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + derived_shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.derived_shape_aspect.self.deriving_relationships) > 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY presentation_view # +#################### +class presentation_view(presentation_representation): + '''Entity presentation_view definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , inherited3__representation_context_of_items , ): + presentation_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , inherited3__representation_context_of_items , ) + +#################### + # ENTITY sin_function # +#################### +class sin_function(unary_function_call): + '''Entity sin_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY text_literal # +#################### +class text_literal(geometric_representation_item): + '''Entity text_literal definition. + + :param literal + :type literal:presentable_text + + :param placement + :type placement:axis2_placement + + :param alignment + :type alignment:text_alignment + + :param path + :type path:text_path + + :param font + :type font:font_select + ''' + def __init__( self , inherited0__name , literal,placement,alignment,path,font, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.literal = literal + self.placement = placement + self.alignment = alignment + self.path = path + self.font = font + + @apply + def literal(): + def fget( self ): + return self._literal + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument literal is mantatory and can not be set to None') + if not check_type(value,presentable_text): + self._literal = presentable_text(value) + else: + self._literal = value + return property(**locals()) + + @apply + def placement(): + def fget( self ): + return self._placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placement is mantatory and can not be set to None') + if not check_type(value,axis2_placement): + self._placement = axis2_placement(value) + else: + self._placement = value + return property(**locals()) + + @apply + def alignment(): + def fget( self ): + return self._alignment + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument alignment is mantatory and can not be set to None') + if not check_type(value,text_alignment): + self._alignment = text_alignment(value) + else: + self._alignment = value + return property(**locals()) + + @apply + def path(): + def fget( self ): + return self._path + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument path is mantatory and can not be set to None') + if not check_type(value,text_path): + self._path = text_path(value) + else: + self._path = value + return property(**locals()) + + @apply + def font(): + def fget( self ): + return self._font + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument font is mantatory and can not be set to None') + if not check_type(value,font_select): + self._font = font_select(value) + else: + self._font = value + return property(**locals()) + +#################### + # ENTITY text_literal_with_delineation # +#################### +class text_literal_with_delineation(text_literal): + '''Entity text_literal_with_delineation definition. + + :param delineation + :type delineation:text_delineation + ''' + def __init__( self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , delineation, ): + text_literal.__init__(self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , ) + self.delineation = delineation + + @apply + def delineation(): + def fget( self ): + return self._delineation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument delineation is mantatory and can not be set to None') + if not check_type(value,text_delineation): + self._delineation = text_delineation(value) + else: + self._delineation = value + return property(**locals()) + +#################### + # ENTITY contact_ratio_representation # +#################### +class contact_ratio_representation(representation): + '''Entity contact_ratio_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = ((SIZEOF(self.self.items) == 1) and (SIZEOF(None) == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(None) == 1) and (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.USED_REPRESENTATION')) == 1) and (SIZEOF(None) == 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY dimensional_characteristic_representation # +#################### +class dimensional_characteristic_representation(BaseEntityClass): + '''Entity dimensional_characteristic_representation definition. + + :param dimension + :type dimension:dimensional_characteristic + + :param representation + :type representation:shape_dimension_representation + ''' + def __init__( self , dimension,representation, ): + self.dimension = dimension + self.representation = representation + + @apply + def dimension(): + def fget( self ): + return self._dimension + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dimension is mantatory and can not be set to None') + if not check_type(value,dimensional_characteristic): + self._dimension = dimensional_characteristic(value) + else: + self._dimension = value + return property(**locals()) + + @apply + def representation(): + def fget( self ): + return self._representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation is mantatory and can not be set to None') + if not check_type(value,shape_dimension_representation): + self._representation = shape_dimension_representation(value) + else: + self._representation = value + return property(**locals()) + +#################### + # ENTITY joggle_termination # +#################### +class joggle_termination(shape_aspect): + '''Entity joggle_termination definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.description == ['value termination','face termination']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((self.self.description == 'value termination') XOR (SIZEOF(None) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.description != 'value termination') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'value termination') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'value termination') or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY tolerance_zone_definition # +#################### +class tolerance_zone_definition(BaseEntityClass): + '''Entity tolerance_zone_definition definition. + + :param zone + :type zone:tolerance_zone + + :param boundaries + :type boundaries:SET(1,None,'shape_aspect', scope = schema_scope) + ''' + def __init__( self , zone,boundaries, ): + self.zone = zone + self.boundaries = boundaries + + @apply + def zone(): + def fget( self ): + return self._zone + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument zone is mantatory and can not be set to None') + if not check_type(value,tolerance_zone): + self._zone = tolerance_zone(value) + else: + self._zone = value + return property(**locals()) + + @apply + def boundaries(): + def fget( self ): + return self._boundaries + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument boundaries is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'shape_aspect', scope = schema_scope)): + self._boundaries = SET(value) + else: + self._boundaries = value + return property(**locals()) + +#################### + # ENTITY projected_zone_definition # +#################### +class projected_zone_definition(tolerance_zone_definition): + '''Entity projected_zone_definition definition. + + :param projection_end + :type projection_end:shape_aspect + + :param projected_length + :type projected_length:measure_with_unit + ''' + def __init__( self , inherited0__zone , inherited1__boundaries , projection_end,projected_length, ): + tolerance_zone_definition.__init__(self , inherited0__zone , inherited1__boundaries , ) + self.projection_end = projection_end + self.projected_length = projected_length + + @apply + def projection_end(): + def fget( self ): + return self._projection_end + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument projection_end is mantatory and can not be set to None') + if not check_type(value,shape_aspect): + self._projection_end = shape_aspect(value) + else: + self._projection_end = value + return property(**locals()) + + @apply + def projected_length(): + def fget( self ): + return self._projected_length + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument projected_length is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._projected_length = measure_with_unit(value) + else: + self._projected_length = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('NUMBER' == TYPEOF(self.projected_length.self.measure_with_unit.self.value_component)) and (self.projected_length.self.measure_with_unit.self.value_component > 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (derive_dimensional_exponents(self.projected_length.self.measure_with_unit.self.unit_component) == dimensional_exponents(1,0,0,0,0,0,0)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY qualitative_uncertainty # +#################### +class qualitative_uncertainty(uncertainty_qualifier): + '''Entity qualitative_uncertainty definition. + + :param uncertainty_value + :type uncertainty_value:text + ''' + def __init__( self , inherited0__measure_name , inherited1__description , uncertainty_value, ): + uncertainty_qualifier.__init__(self , inherited0__measure_name , inherited1__description , ) + self.uncertainty_value = uncertainty_value + + @apply + def uncertainty_value(): + def fget( self ): + return self._uncertainty_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument uncertainty_value is mantatory and can not be set to None') + if not check_type(value,text): + self._uncertainty_value = text(value) + else: + self._uncertainty_value = value + return property(**locals()) + +#################### + # ENTITY applied_classification_assignment # +#################### +class applied_classification_assignment(classification_assignment): + '''Entity applied_classification_assignment definition. + + :param items + :type items:SET(1,None,'classification_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_class , inherited1__role , items, ): + classification_assignment.__init__(self , inherited0__assigned_class , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'classification_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'CLASS') == TYPEOF(self.self.assigned_class))) or (SIZEOF(None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not (((('AUTOMOTIVE_DESIGN.' + 'GROUP') == TYPEOF(self.self.assigned_class)) and (self.self.assigned_class.self.group.self.name == 'E')) and (self.self.assigned_class.self.group.self.description == 'dimensioning principle'))) or (SIZEOF(None) == 0)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not ((('AUTOMOTIVE_DESIGN.' + 'CLASS_SYSTEM') == TYPEOF(self.self.assigned_class)) and (self.self.role.self.name == 'class system membership'))) or (SIZEOF(None) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY circular_runout_tolerance # +#################### +class circular_runout_tolerance(geometric_tolerance_with_datum_reference): + '''Entity circular_runout_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ): + geometric_tolerance_with_datum_reference.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) <= 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY bounded_surface_curve # +#################### +class bounded_surface_curve(surface_curve,bounded_curve): + '''Entity bounded_surface_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__curve_3d , inherited2__associated_geometry , inherited3__master_representation , inherited4__name , ): + surface_curve.__init__(self , inherited0__name , inherited1__curve_3d , inherited2__associated_geometry , inherited3__master_representation , ) + bounded_curve.__init__(self , inherited4__name , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.BOUNDED_CURVE' == TYPEOF(self.self.surface_curve.self.curve_3d)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY document # +#################### +class document(BaseEntityClass): + '''Entity document definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + + :param kind + :type kind:document_type + + :param representation_types + :type representation_types:SET(0,None,'document_representation_type', scope = schema_scope) + ''' + def __init__( self , id,name,description,kind, ): + self.id = id + self.name = name + self.description = description + self.kind = kind + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def kind(): + def fget( self ): + return self._kind + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument kind is mantatory and can not be set to None') + if not check_type(value,document_type): + self._kind = document_type(value) + else: + self._kind = value + return property(**locals()) + + @apply + def representation_types(): + def fget( self ): + return self._representation_types + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument representation_types is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY document_file # +#################### +class document_file(document,characterized_object): + '''Entity document_file definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__kind , inherited4__name , inherited5__description , ): + document.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__kind , ) + characterized_object.__init__(self , inherited4__name , inherited5__description , ) + def wr1(self): + eval_wr1_wr = (self.self.characterized_object.self.name == '') + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ( not EXISTS(self.self.characterized_object.self.description)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY versioned_action_request_relationship # +#################### +class versioned_action_request_relationship(BaseEntityClass): + '''Entity versioned_action_request_relationship definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + + :param relating_versioned_action_request + :type relating_versioned_action_request:versioned_action_request + + :param related_versioned_action_request + :type related_versioned_action_request:versioned_action_request + ''' + def __init__( self , id,name,description,relating_versioned_action_request,related_versioned_action_request, ): + self.id = id + self.name = name + self.description = description + self.relating_versioned_action_request = relating_versioned_action_request + self.related_versioned_action_request = related_versioned_action_request + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_versioned_action_request(): + def fget( self ): + return self._relating_versioned_action_request + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_versioned_action_request is mantatory and can not be set to None') + if not check_type(value,versioned_action_request): + self._relating_versioned_action_request = versioned_action_request(value) + else: + self._relating_versioned_action_request = value + return property(**locals()) + + @apply + def related_versioned_action_request(): + def fget( self ): + return self._related_versioned_action_request + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_versioned_action_request is mantatory and can not be set to None') + if not check_type(value,versioned_action_request): + self._related_versioned_action_request = versioned_action_request(value) + else: + self._related_versioned_action_request = value + return property(**locals()) + +#################### + # ENTITY class_system # +#################### +class class_system(group): + '''Entity class_system definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + group.__init__(self , inherited0__name , inherited1__description , ) + +#################### + # ENTITY multiple_arity_function_call # +#################### +class multiple_arity_function_call(multiple_arity_numeric_expression): + '''Entity multiple_arity_function_call definition. + ''' + def __init__( self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ): + multiple_arity_numeric_expression.__init__(self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ) + +#################### + # ENTITY maximum_function # +#################### +class maximum_function(multiple_arity_function_call): + '''Entity maximum_function definition. + ''' + def __init__( self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ): + multiple_arity_function_call.__init__(self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ) + +#################### + # ENTITY mechanism # +#################### +class mechanism(BaseEntityClass): + '''Entity mechanism definition. + + :param structure_definition + :type structure_definition:kinematic_structure + + :param base + :type base:kinematic_link + + :param containing_property + :type containing_property:kinematic_property_definition + ''' + def __init__( self , structure_definition,base,containing_property, ): + self.structure_definition = structure_definition + self.base = base + self.containing_property = containing_property + + @apply + def structure_definition(): + def fget( self ): + return self._structure_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument structure_definition is mantatory and can not be set to None') + if not check_type(value,kinematic_structure): + self._structure_definition = kinematic_structure(value) + else: + self._structure_definition = value + return property(**locals()) + + @apply + def base(): + def fget( self ): + return self._base + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument base is mantatory and can not be set to None') + if not check_type(value,kinematic_link): + self._base = kinematic_link(value) + else: + self._base = value + return property(**locals()) + + @apply + def containing_property(): + def fget( self ): + return self._containing_property + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument containing_property is mantatory and can not be set to None') + if not check_type(value,kinematic_property_definition): + self._containing_property = kinematic_property_definition(value) + else: + self._containing_property = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_category_relationship # +#################### +class product_category_relationship(BaseEntityClass): + '''Entity product_category_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param category + :type category:product_category + + :param sub_category + :type sub_category:product_category + ''' + def __init__( self , name,description,category,sub_category, ): + self.name = name + self.description = description + self.category = category + self.sub_category = sub_category + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def category(): + def fget( self ): + return self._category + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument category is mantatory and can not be set to None') + if not check_type(value,product_category): + self._category = product_category(value) + else: + self._category = value + return property(**locals()) + + @apply + def sub_category(): + def fget( self ): + return self._sub_category + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sub_category is mantatory and can not be set to None') + if not check_type(value,product_category): + self._sub_category = product_category(value) + else: + self._sub_category = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = acyclic_product_category_relationship(self,[self.self.sub_category]) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY surface_condition_callout # +#################### +class surface_condition_callout(draughting_callout): + '''Entity surface_condition_callout definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY text_literal_with_blanking_box # +#################### +class text_literal_with_blanking_box(text_literal): + '''Entity text_literal_with_blanking_box definition. + + :param blanking + :type blanking:planar_box + ''' + def __init__( self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , blanking, ): + text_literal.__init__(self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , ) + self.blanking = blanking + + @apply + def blanking(): + def fget( self ): + return self._blanking + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument blanking is mantatory and can not be set to None') + if not check_type(value,planar_box): + self._blanking = planar_box(value) + else: + self._blanking = value + return property(**locals()) + +#################### + # ENTITY curve_style_font_pattern # +#################### +class curve_style_font_pattern(founded_item): + '''Entity curve_style_font_pattern definition. + + :param visible_segment_length + :type visible_segment_length:positive_length_measure + + :param invisible_segment_length + :type invisible_segment_length:positive_length_measure + ''' + def __init__( self , visible_segment_length,invisible_segment_length, ): + founded_item.__init__(self , ) + self.visible_segment_length = visible_segment_length + self.invisible_segment_length = invisible_segment_length + + @apply + def visible_segment_length(): + def fget( self ): + return self._visible_segment_length + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument visible_segment_length is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._visible_segment_length = positive_length_measure(value) + else: + self._visible_segment_length = value + return property(**locals()) + + @apply + def invisible_segment_length(): + def fget( self ): + return self._invisible_segment_length + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument invisible_segment_length is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._invisible_segment_length = positive_length_measure(value) + else: + self._invisible_segment_length = value + return property(**locals()) + +#################### + # ENTITY kinematic_frame_based_transformation # +#################### +class kinematic_frame_based_transformation(geometric_representation_item,functionally_defined_transformation): + '''Entity kinematic_frame_based_transformation definition. + + :param transformator + :type transformator:rigid_placement + ''' + def __init__( self , inherited0__name , inherited1__name , inherited2__description , transformator, ): + geometric_representation_item.__init__(self , inherited0__name , ) + functionally_defined_transformation.__init__(self , inherited1__name , inherited2__description , ) + self.transformator = transformator + + @apply + def transformator(): + def fget( self ): + return self._transformator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transformator is mantatory and can not be set to None') + if not check_type(value,rigid_placement): + self._transformator = rigid_placement(value) + else: + self._transformator = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.geometric_representation_item.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY constructive_geometry_representation # +#################### +class constructive_geometry_representation(representation): + '''Entity constructive_geometry_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_REPRESENTATION_CONTEXT') == TYPEOF(self.self.context_of_items)) and ((2 <= self.self.context_of_items.self.geometric_representation_context.self.coordinate_space_dimension) and (self.self.context_of_items.self.geometric_representation_context.self.coordinate_space_dimension <= 3))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.REPRESENTATION_RELATIONSHIP.REP_2')) > 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.REPRESENTATION_MAP.MAPPED_REPRESENTATION')) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY plane_angle_measure_with_unit # +#################### +class plane_angle_measure_with_unit(measure_with_unit): + '''Entity plane_angle_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.PLANE_ANGLE_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY right_angular_wedge # +#################### +class right_angular_wedge(geometric_representation_item): + '''Entity right_angular_wedge definition. + + :param position + :type position:axis2_placement_3d + + :param x + :type x:positive_length_measure + + :param y + :type y:positive_length_measure + + :param z + :type z:positive_length_measure + + :param ltx + :type ltx:length_measure + ''' + def __init__( self , inherited0__name , position,x,y,z,ltx, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.position = position + self.x = x + self.y = y + self.z = z + self.ltx = ltx + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,axis2_placement_3d): + self._position = axis2_placement_3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def x(): + def fget( self ): + return self._x + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument x is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._x = positive_length_measure(value) + else: + self._x = value + return property(**locals()) + + @apply + def y(): + def fget( self ): + return self._y + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument y is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._y = positive_length_measure(value) + else: + self._y = value + return property(**locals()) + + @apply + def z(): + def fget( self ): + return self._z + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument z is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._z = positive_length_measure(value) + else: + self._z = value + return property(**locals()) + + @apply + def ltx(): + def fget( self ): + return self._ltx + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ltx is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._ltx = length_measure(value) + else: + self._ltx = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((0 <= self.ltx) and (self.ltx < self.x)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY text_style_with_spacing # +#################### +class text_style_with_spacing(text_style): + '''Entity text_style_with_spacing definition. + + :param character_spacing + :type character_spacing:character_spacing_select + ''' + def __init__( self , inherited0__name , inherited1__character_appearance , character_spacing, ): + text_style.__init__(self , inherited0__name , inherited1__character_appearance , ) + self.character_spacing = character_spacing + + @apply + def character_spacing(): + def fget( self ): + return self._character_spacing + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument character_spacing is mantatory and can not be set to None') + if not check_type(value,character_spacing_select): + self._character_spacing = character_spacing_select(value) + else: + self._character_spacing = value + return property(**locals()) + +#################### + # ENTITY vertex # +#################### +class vertex(topological_representation_item): + '''Entity vertex definition. + ''' + def __init__( self , inherited0__name , ): + topological_representation_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY attribute_classification_assignment # +#################### +class attribute_classification_assignment(BaseEntityClass): + '''Entity attribute_classification_assignment definition. + + :param assigned_class + :type assigned_class:group + + :param attribute_name + :type attribute_name:label + + :param role + :type role:classification_role + ''' + def __init__( self , assigned_class,attribute_name,role, ): + self.assigned_class = assigned_class + self.attribute_name = attribute_name + self.role = role + + @apply + def assigned_class(): + def fget( self ): + return self._assigned_class + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_class is mantatory and can not be set to None') + if not check_type(value,group): + self._assigned_class = group(value) + else: + self._assigned_class = value + return property(**locals()) + + @apply + def attribute_name(): + def fget( self ): + return self._attribute_name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument attribute_name is mantatory and can not be set to None') + if not check_type(value,label): + self._attribute_name = label(value) + else: + self._attribute_name = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,classification_role): + self._role = classification_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY point_on_planar_curve_pair # +#################### +class point_on_planar_curve_pair(kinematic_pair): + '''Entity point_on_planar_curve_pair definition. + + :param pair_curve + :type pair_curve:curve + + :param orientation + :type orientation:BOOLEAN + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , pair_curve,orientation, ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + self.pair_curve = pair_curve + self.orientation = orientation + + @apply + def pair_curve(): + def fget( self ): + return self._pair_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_curve is mantatory and can not be set to None') + if not check_type(value,curve): + self._pair_curve = curve(value) + else: + self._pair_curve = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = frame_associated_to_background(self.self.kinematic_pair.self.pair_placement_in_first_link_context,self.pair_curve) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY abs_function # +#################### +class abs_function(unary_function_call): + '''Entity abs_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY electric_current_unit # +#################### +class electric_current_unit(named_unit): + '''Entity electric_current_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 0) and (self.self.named_unit.self.dimensions.self.mass_exponent == 0)) and (self.self.named_unit.self.dimensions.self.time_exponent == 0)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 1)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 0)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 0)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY plus_expression # +#################### +class plus_expression(multiple_arity_numeric_expression): + '''Entity plus_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ): + multiple_arity_numeric_expression.__init__(self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ) + +#################### + # ENTITY application_context_relationship # +#################### +class application_context_relationship(BaseEntityClass): + '''Entity application_context_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_context + :type relating_context:application_context + + :param related_context + :type related_context:application_context + ''' + def __init__( self , name,description,relating_context,related_context, ): + self.name = name + self.description = description + self.relating_context = relating_context + self.related_context = related_context + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_context(): + def fget( self ): + return self._relating_context + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_context is mantatory and can not be set to None') + if not check_type(value,application_context): + self._relating_context = application_context(value) + else: + self._relating_context = value + return property(**locals()) + + @apply + def related_context(): + def fget( self ): + return self._related_context + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_context is mantatory and can not be set to None') + if not check_type(value,application_context): + self._related_context = application_context(value) + else: + self._related_context = value + return property(**locals()) + +#################### + # ENTITY product_definition_effectivity # +#################### +class product_definition_effectivity(effectivity): + '''Entity product_definition_effectivity definition. + + :param usage + :type usage:product_definition_relationship + ''' + def __init__( self , inherited0__id , usage, ): + effectivity.__init__(self , inherited0__id , ) + self.usage = usage + + @apply + def usage(): + def fget( self ): + return self._usage + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument usage is mantatory and can not be set to None') + if not check_type(value,product_definition_relationship): + self._usage = product_definition_relationship(value) + else: + self._usage = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.EFFECTIVITY_ASSIGNMENT.ASSIGNED_EFFECTIVITY')) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY configuration_effectivity # +#################### +class configuration_effectivity(product_definition_effectivity): + '''Entity configuration_effectivity definition. + + :param configuration + :type configuration:configuration_design + ''' + def __init__( self , inherited0__id , inherited1__usage , configuration, ): + product_definition_effectivity.__init__(self , inherited0__id , inherited1__usage , ) + self.configuration = configuration + + @apply + def configuration(): + def fget( self ): + return self._configuration + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument configuration is mantatory and can not be set to None') + if not check_type(value,configuration_design): + self._configuration = configuration_design(value) + else: + self._configuration = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_USAGE' == TYPEOF(self.self.product_definition_effectivity.self.usage)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ellipse # +#################### +class ellipse(conic): + '''Entity ellipse definition. + + :param semi_axis_1 + :type semi_axis_1:positive_length_measure + + :param semi_axis_2 + :type semi_axis_2:positive_length_measure + ''' + def __init__( self , inherited0__name , inherited1__position , semi_axis_1,semi_axis_2, ): + conic.__init__(self , inherited0__name , inherited1__position , ) + self.semi_axis_1 = semi_axis_1 + self.semi_axis_2 = semi_axis_2 + + @apply + def semi_axis_1(): + def fget( self ): + return self._semi_axis_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semi_axis_1 is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._semi_axis_1 = positive_length_measure(value) + else: + self._semi_axis_1 = value + return property(**locals()) + + @apply + def semi_axis_2(): + def fget( self ): + return self._semi_axis_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semi_axis_2 is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._semi_axis_2 = positive_length_measure(value) + else: + self._semi_axis_2 = value + return property(**locals()) + +#################### + # ENTITY geometric_tolerance_with_defined_unit # +#################### +class geometric_tolerance_with_defined_unit(geometric_tolerance): + '''Entity geometric_tolerance_with_defined_unit definition. + + :param unit_size + :type unit_size:measure_with_unit + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , unit_size, ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + self.unit_size = unit_size + + @apply + def unit_size(): + def fget( self ): + return self._unit_size + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unit_size is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._unit_size = measure_with_unit(value) + else: + self._unit_size = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('NUMBER' == TYPEOF(self.unit_size.self.measure_with_unit.self.value_component)) and (self.unit_size.self.measure_with_unit.self.value_component > 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY surface_style_fill_area # +#################### +class surface_style_fill_area(founded_item): + '''Entity surface_style_fill_area definition. + + :param fill_area + :type fill_area:fill_area_style + ''' + def __init__( self , fill_area, ): + founded_item.__init__(self , ) + self.fill_area = fill_area + + @apply + def fill_area(): + def fget( self ): + return self._fill_area + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fill_area is mantatory and can not be set to None') + if not check_type(value,fill_area_style): + self._fill_area = fill_area_style(value) + else: + self._fill_area = value + return property(**locals()) + +#################### + # ENTITY simple_boolean_expression # +#################### +class simple_boolean_expression(boolean_expression,simple_generic_expression): + '''Entity simple_boolean_expression definition. + ''' + def __init__( self , ): + boolean_expression.__init__(self , ) + simple_generic_expression.__init__(self , ) + +#################### + # ENTITY boolean_variable # +#################### +class boolean_variable(simple_boolean_expression,variable): + '''Entity boolean_variable definition. + ''' + def __init__( self , ): + simple_boolean_expression.__init__(self , ) + variable.__init__(self , ) + +#################### + # ENTITY camera_usage # +#################### +class camera_usage(representation_map): + '''Entity camera_usage definition. + + :param representation_map_mapping_origin + :type representation_map_mapping_origin:camera_model + ''' + def __init__( self , inherited0__mapping_origin , inherited1__mapped_representation , representation_map_mapping_origin, ): + representation_map.__init__(self , inherited0__mapping_origin , inherited1__mapped_representation , ) + self.representation_map_mapping_origin = representation_map_mapping_origin + + @apply + def representation_map_mapping_origin(): + def fget( self ): + return self._representation_map_mapping_origin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_map_mapping_origin is mantatory and can not be set to None') + if not check_type(value,camera_model): + self._representation_map_mapping_origin = camera_model(value) + else: + self._representation_map_mapping_origin = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('AUTOMOTIVE_DESIGN.PRESENTATION_REPRESENTATION' == TYPEOF(self.self.representation_map.self.mapped_representation))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY geometrically_bounded_2d_wireframe_representation # +#################### +class geometrically_bounded_2d_wireframe_representation(shape_representation): + '''Entity geometrically_bounded_2d_wireframe_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (self.self.context_of_items.self.geometric_representation_context.self.coordinate_space_dimension == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) >= 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY bead_end # +#################### +class bead_end(shape_aspect): + '''Entity bead_end definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.description == ['linear','open','radiused']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((self.self.description != 'linear') XOR (SIZEOF(None) > 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.description != 'linear') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'linear') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'linear') or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY comparison_greater_equal # +#################### +class comparison_greater_equal(comparison_expression): + '''Entity comparison_greater_equal definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + comparison_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY externally_defined_item_relationship # +#################### +class externally_defined_item_relationship(BaseEntityClass): + '''Entity externally_defined_item_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_item + :type relating_item:externally_defined_item + + :param related_item + :type related_item:externally_defined_item + ''' + def __init__( self , name,description,relating_item,related_item, ): + self.name = name + self.description = description + self.relating_item = relating_item + self.related_item = related_item + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_item(): + def fget( self ): + return self._relating_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_item is mantatory and can not be set to None') + if not check_type(value,externally_defined_item): + self._relating_item = externally_defined_item(value) + else: + self._relating_item = value + return property(**locals()) + + @apply + def related_item(): + def fget( self ): + return self._related_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_item is mantatory and can not be set to None') + if not check_type(value,externally_defined_item): + self._related_item = externally_defined_item(value) + else: + self._related_item = value + return property(**locals()) + +#################### + # ENTITY int_literal # +#################### +class int_literal(literal_number): + '''Entity int_literal definition. + + :param literal_number_the_value + :type literal_number_the_value:INTEGER + ''' + def __init__( self , inherited0__the_value , literal_number_the_value, ): + literal_number.__init__(self , inherited0__the_value , ) + self.literal_number_the_value = literal_number_the_value + + @apply + def literal_number_the_value(): + def fget( self ): + return self._literal_number_the_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument literal_number_the_value is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._literal_number_the_value = INTEGER(value) + else: + self._literal_number_the_value = value + return property(**locals()) + +#################### + # ENTITY point_on_surface_pair # +#################### +class point_on_surface_pair(kinematic_pair): + '''Entity point_on_surface_pair definition. + + :param pair_surface + :type pair_surface:surface + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , pair_surface, ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + self.pair_surface = pair_surface + + @apply + def pair_surface(): + def fget( self ): + return self._pair_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._pair_surface = surface(value) + else: + self._pair_surface = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = frame_associated_to_background(self.self.kinematic_pair.self.pair_placement_in_first_link_context,self.pair_surface) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY uncertainty_assigned_representation # +#################### +class uncertainty_assigned_representation(representation): + '''Entity uncertainty_assigned_representation definition. + + :param uncertainty + :type uncertainty:SET(1,None,'uncertainty_measure_with_unit', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , uncertainty, ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + self.uncertainty = uncertainty + + @apply + def uncertainty(): + def fget( self ): + return self._uncertainty + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument uncertainty is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'uncertainty_measure_with_unit', scope = schema_scope)): + self._uncertainty = SET(value) + else: + self._uncertainty = value + return property(**locals()) + +#################### + # ENTITY value_function # +#################### +class value_function(numeric_expression,unary_generic_expression): + '''Entity value_function definition. + + :param unary_generic_expression_operand + :type unary_generic_expression_operand:string_expression + ''' + def __init__( self , inherited0__operand , unary_generic_expression_operand, ): + numeric_expression.__init__(self , ) + unary_generic_expression.__init__(self , inherited0__operand , ) + self.unary_generic_expression_operand = unary_generic_expression_operand + + @apply + def unary_generic_expression_operand(): + def fget( self ): + return self._unary_generic_expression_operand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unary_generic_expression_operand is mantatory and can not be set to None') + if not check_type(value,string_expression): + self._unary_generic_expression_operand = string_expression(value) + else: + self._unary_generic_expression_operand = value + return property(**locals()) + +#################### + # ENTITY alternate_product_relationship # +#################### +class alternate_product_relationship(BaseEntityClass): + '''Entity alternate_product_relationship definition. + + :param name + :type name:label + + :param definition + :type definition:text + + :param alternate + :type alternate:product + + :param base + :type base:product + + :param basis + :type basis:text + ''' + def __init__( self , name,definition,alternate,base,basis, ): + self.name = name + self.definition = definition + self.alternate = alternate + self.base = base + self.basis = basis + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._definition = text(value) + else: + self._definition = value + else: + self._definition = value + return property(**locals()) + + @apply + def alternate(): + def fget( self ): + return self._alternate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument alternate is mantatory and can not be set to None') + if not check_type(value,product): + self._alternate = product(value) + else: + self._alternate = value + return property(**locals()) + + @apply + def base(): + def fget( self ): + return self._base + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument base is mantatory and can not be set to None') + if not check_type(value,product): + self._base = product(value) + else: + self._base = value + return property(**locals()) + + @apply + def basis(): + def fget( self ): + return self._basis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis is mantatory and can not be set to None') + if not check_type(value,text): + self._basis = text(value) + else: + self._basis = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.alternate != self.base) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY document_type # +#################### +class document_type(BaseEntityClass): + '''Entity document_type definition. + + :param product_data_type + :type product_data_type:label + ''' + def __init__( self , product_data_type, ): + self.product_data_type = product_data_type + + @apply + def product_data_type(): + def fget( self ): + return self._product_data_type + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument product_data_type is mantatory and can not be set to None') + if not check_type(value,label): + self._product_data_type = label(value) + else: + self._product_data_type = value + return property(**locals()) + +#################### + # ENTITY externally_defined_style # +#################### +class externally_defined_style(externally_defined_item,founded_item): + '''Entity externally_defined_style definition. + ''' + def __init__( self , inherited0__item_id , inherited1__source , ): + externally_defined_item.__init__(self , inherited0__item_id , inherited1__source , ) + founded_item.__init__(self , ) + +#################### + # ENTITY document_reference # +#################### +class document_reference(BaseEntityClass): + '''Entity document_reference definition. + + :param assigned_document + :type assigned_document:document + + :param source + :type source:label + + :param role + :type role:object_role + ''' + def __init__( self , assigned_document,source, ): + self.assigned_document = assigned_document + self.source = source + + @apply + def assigned_document(): + def fget( self ): + return self._assigned_document + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_document is mantatory and can not be set to None') + if not check_type(value,document): + self._assigned_document = document(value) + else: + self._assigned_document = value + return property(**locals()) + + @apply + def source(): + def fget( self ): + return self._source + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument source is mantatory and can not be set to None') + if not check_type(value,label): + self._source = label(value) + else: + self._source = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY binary_boolean_expression # +#################### +class binary_boolean_expression(boolean_expression,binary_generic_expression): + '''Entity binary_boolean_expression definition. + ''' + def __init__( self , inherited0__operands , ): + boolean_expression.__init__(self , ) + binary_generic_expression.__init__(self , inherited0__operands , ) + +#################### + # ENTITY equals_expression # +#################### +class equals_expression(binary_boolean_expression): + '''Entity equals_expression definition. + ''' + def __init__( self , inherited0__operands , ): + binary_boolean_expression.__init__(self , inherited0__operands , ) + +#################### + # ENTITY seam_edge # +#################### +class seam_edge(oriented_edge): + '''Entity seam_edge definition. + + :param pcurve_reference + :type pcurve_reference:pcurve + ''' + def __init__( self , inherited0__name , inherited1__edge_start , inherited2__edge_end , inherited3__edge_element , inherited4__orientation , pcurve_reference, ): + oriented_edge.__init__(self , inherited0__name , inherited1__edge_start , inherited2__edge_end , inherited3__edge_element , inherited4__orientation , ) + self.pcurve_reference = pcurve_reference + + @apply + def pcurve_reference(): + def fget( self ): + return self._pcurve_reference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pcurve_reference is mantatory and can not be set to None') + if not check_type(value,pcurve): + self._pcurve_reference = pcurve(value) + else: + self._pcurve_reference = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.EDGE_CURVE' == TYPEOF(self.edge_element)) and ('AUTOMOTIVE_DESIGN.SEAM_CURVE' == TYPEOF(self.edge_element.self.edge_curve.self.edge_geometry))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.pcurve_reference == self.edge_element.self.edge_curve.self.edge_geometry.self.surface_curve.self.associated_geometry) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY acos_function # +#################### +class acos_function(unary_function_call): + '''Entity acos_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY like_expression # +#################### +class like_expression(comparison_expression): + '''Entity like_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + comparison_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.self.comparison_expression.self.operands[1])) and ('AUTOMOTIVE_DESIGN.STRING_EXPRESSION' == TYPEOF(self.self.comparison_expression.self.operands[2]))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY draughting_symbol_representation # +#################### +class draughting_symbol_representation(symbol_representation): + '''Entity draughting_symbol_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + symbol_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) >= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) > 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ( not acyclic_mapped_item_usage(self)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(self.self.context_of_items.self.representations_in_context) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + +#################### + # ENTITY planar_extent # +#################### +class planar_extent(geometric_representation_item): + '''Entity planar_extent definition. + + :param size_in_x + :type size_in_x:length_measure + + :param size_in_y + :type size_in_y:length_measure + ''' + def __init__( self , inherited0__name , size_in_x,size_in_y, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.size_in_x = size_in_x + self.size_in_y = size_in_y + + @apply + def size_in_x(): + def fget( self ): + return self._size_in_x + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument size_in_x is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._size_in_x = length_measure(value) + else: + self._size_in_x = value + return property(**locals()) + + @apply + def size_in_y(): + def fget( self ): + return self._size_in_y + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument size_in_y is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._size_in_y = length_measure(value) + else: + self._size_in_y = value + return property(**locals()) + +#################### + # ENTITY planar_box # +#################### +class planar_box(planar_extent): + '''Entity planar_box definition. + + :param placement + :type placement:axis2_placement + ''' + def __init__( self , inherited0__name , inherited1__size_in_x , inherited2__size_in_y , placement, ): + planar_extent.__init__(self , inherited0__name , inherited1__size_in_x , inherited2__size_in_y , ) + self.placement = placement + + @apply + def placement(): + def fget( self ): + return self._placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placement is mantatory and can not be set to None') + if not check_type(value,axis2_placement): + self._placement = axis2_placement(value) + else: + self._placement = value + return property(**locals()) + +#################### + # ENTITY slot # +#################### +class slot(feature_definition): + '''Entity slot definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY manifold_subsurface_shape_representation # +#################### +class manifold_subsurface_shape_representation(shape_representation): + '''Entity manifold_subsurface_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 0) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 0) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) == 0) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(None) == 0) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + +#################### + # ENTITY perpendicularity_tolerance # +#################### +class perpendicularity_tolerance(geometric_tolerance_with_datum_reference): + '''Entity perpendicularity_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ): + geometric_tolerance_with_datum_reference.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) <= 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY plus_minus_tolerance # +#################### +class plus_minus_tolerance(BaseEntityClass): + '''Entity plus_minus_tolerance definition. + + :param range + :type range:tolerance_method_definition + + :param toleranced_dimension + :type toleranced_dimension:dimensional_characteristic + ''' + def __init__( self , range,toleranced_dimension, ): + self.range = range + self.toleranced_dimension = toleranced_dimension + + @apply + def range(): + def fget( self ): + return self._range + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument range is mantatory and can not be set to None') + if not check_type(value,tolerance_method_definition): + self._range = tolerance_method_definition(value) + else: + self._range = value + return property(**locals()) + + @apply + def toleranced_dimension(): + def fget( self ): + return self._toleranced_dimension + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument toleranced_dimension is mantatory and can not be set to None') + if not check_type(value,dimensional_characteristic): + self._toleranced_dimension = dimensional_characteristic(value) + else: + self._toleranced_dimension = value + return property(**locals()) + +#################### + # ENTITY drawing_sheet_layout # +#################### +class drawing_sheet_layout(draughting_symbol_representation): + '''Entity drawing_sheet_layout definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + draughting_symbol_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + +#################### + # ENTITY effectivity_relationship # +#################### +class effectivity_relationship(BaseEntityClass): + '''Entity effectivity_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param related_effectivity + :type related_effectivity:effectivity + + :param relating_effectivity + :type relating_effectivity:effectivity + ''' + def __init__( self , name,description,related_effectivity,relating_effectivity, ): + self.name = name + self.description = description + self.related_effectivity = related_effectivity + self.relating_effectivity = relating_effectivity + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def related_effectivity(): + def fget( self ): + return self._related_effectivity + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_effectivity is mantatory and can not be set to None') + if not check_type(value,effectivity): + self._related_effectivity = effectivity(value) + else: + self._related_effectivity = value + return property(**locals()) + + @apply + def relating_effectivity(): + def fget( self ): + return self._relating_effectivity + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_effectivity is mantatory and can not be set to None') + if not check_type(value,effectivity): + self._relating_effectivity = effectivity(value) + else: + self._relating_effectivity = value + return property(**locals()) + +#################### + # ENTITY square_u_profile # +#################### +class square_u_profile(shape_aspect): + '''Entity square_u_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY applied_identification_assignment # +#################### +class applied_identification_assignment(identification_assignment): + '''Entity applied_identification_assignment definition. + + :param items + :type items:SET(1,None,'identification_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_id , inherited1__role , items, ): + identification_assignment.__init__(self , inherited0__assigned_id , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'identification_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (self.self.role.self.name == 'version')) or item_correlation(self.self.items,['ACTION','ACTION_DIRECTIVE','SHAPE_REPRESENTATION','EFFECTIVITY','PRODUCT_CONCEPT','CONFIGURATION_ITEM','PRODUCT_DEFINITION','PRODUCT_CONCEPT_FEATURE','DOCUMENT_FILE','CLASS','APPLIED_IDENTIFICATION_ASSIGNMENT','DRAUGHTING_MODEL','MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION','PRESENTATION_AREA'])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not (self.self.role.self.name == 'lot context')) or item_correlation(self.self.items,['PRODUCT'])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not (self.self.role.self.name == 'property change id context')) or item_correlation(self.self.items,['PROPERTY_DEFINITION_RELATIONSHIP','SHAPE_ASPECT_RELATIONSHIP','ACTION_PROPERTY'])) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (self.self.role.self.name == 'size id')) or item_correlation(self.self.items,['DIMENSIONAL_SIZE'])) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (( not (self.self.role.self.name == 'model change id')) or item_correlation(self.self.items,['PROPERTY_DEFINITION','ACTION_PROPERTY'])) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (( not (self.self.role.self.name == 'alias')) or item_correlation(self.self.items,['APPLICATION_CONTEXT','APPROVAL_STATUS','ASSEMBLY_COMPONENT_USAGE','CLASS','CLASS_SYSTEM','DOCUMENT_TYPE','DRAUGHTING_MODEL','GENERAL_PROPERTY','MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION','ORGANIZATION','PRODUCT','PRODUCT_CONCEPT','PRODUCT_CONCEPT_FEATURE','PRODUCT_CONCEPT_FEATURE_CATEGORY','PRODUCT_DEFINITION','PRODUCT_DEFINITION_FORMATION','PROPERTY_DEFINITION','SECURITY_CLASSIFICATION_LEVEL','SHAPE_REPRESENTATION'])) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + +#################### + # ENTITY contract # +#################### +class contract(BaseEntityClass): + '''Entity contract definition. + + :param name + :type name:label + + :param purpose + :type purpose:text + + :param kind + :type kind:contract_type + ''' + def __init__( self , name,purpose,kind, ): + self.name = name + self.purpose = purpose + self.kind = kind + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument purpose is mantatory and can not be set to None') + if not check_type(value,text): + self._purpose = text(value) + else: + self._purpose = value + return property(**locals()) + + @apply + def kind(): + def fget( self ): + return self._kind + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument kind is mantatory and can not be set to None') + if not check_type(value,contract_type): + self._kind = contract_type(value) + else: + self._kind = value + return property(**locals()) + +#################### + # ENTITY direction_shape_representation # +#################### +class direction_shape_representation(shape_representation): + '''Entity direction_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.items) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY attribute_value_assignment # +#################### +class attribute_value_assignment(BaseEntityClass): + '''Entity attribute_value_assignment definition. + + :param attribute_name + :type attribute_name:label + + :param attribute_value + :type attribute_value:attribute_type + + :param role + :type role:attribute_value_role + ''' + def __init__( self , attribute_name,attribute_value,role, ): + self.attribute_name = attribute_name + self.attribute_value = attribute_value + self.role = role + + @apply + def attribute_name(): + def fget( self ): + return self._attribute_name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument attribute_name is mantatory and can not be set to None') + if not check_type(value,label): + self._attribute_name = label(value) + else: + self._attribute_name = value + return property(**locals()) + + @apply + def attribute_value(): + def fget( self ): + return self._attribute_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument attribute_value is mantatory and can not be set to None') + if not check_type(value,attribute_type): + self._attribute_value = attribute_type(value) + else: + self._attribute_value = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,attribute_value_role): + self._role = attribute_value_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY datum_feature # +#################### +class datum_feature(shape_aspect): + '''Entity datum_feature definition. + + :param feature_basis_relationship + :type feature_basis_relationship:shape_aspect_relationship + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + + @apply + def feature_basis_relationship(): + def fget( self ): + return self._feature_basis_relationship + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument feature_basis_relationship is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.shape_aspect.self.product_definitional == TRUE) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY dimensional_exponents # +#################### +class dimensional_exponents(BaseEntityClass): + '''Entity dimensional_exponents definition. + + :param length_exponent + :type length_exponent:REAL + + :param mass_exponent + :type mass_exponent:REAL + + :param time_exponent + :type time_exponent:REAL + + :param electric_current_exponent + :type electric_current_exponent:REAL + + :param thermodynamic_temperature_exponent + :type thermodynamic_temperature_exponent:REAL + + :param amount_of_substance_exponent + :type amount_of_substance_exponent:REAL + + :param luminous_intensity_exponent + :type luminous_intensity_exponent:REAL + ''' + def __init__( self , length_exponent,mass_exponent,time_exponent,electric_current_exponent,thermodynamic_temperature_exponent,amount_of_substance_exponent,luminous_intensity_exponent, ): + self.length_exponent = length_exponent + self.mass_exponent = mass_exponent + self.time_exponent = time_exponent + self.electric_current_exponent = electric_current_exponent + self.thermodynamic_temperature_exponent = thermodynamic_temperature_exponent + self.amount_of_substance_exponent = amount_of_substance_exponent + self.luminous_intensity_exponent = luminous_intensity_exponent + + @apply + def length_exponent(): + def fget( self ): + return self._length_exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument length_exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._length_exponent = REAL(value) + else: + self._length_exponent = value + return property(**locals()) + + @apply + def mass_exponent(): + def fget( self ): + return self._mass_exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mass_exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._mass_exponent = REAL(value) + else: + self._mass_exponent = value + return property(**locals()) + + @apply + def time_exponent(): + def fget( self ): + return self._time_exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument time_exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._time_exponent = REAL(value) + else: + self._time_exponent = value + return property(**locals()) + + @apply + def electric_current_exponent(): + def fget( self ): + return self._electric_current_exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument electric_current_exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._electric_current_exponent = REAL(value) + else: + self._electric_current_exponent = value + return property(**locals()) + + @apply + def thermodynamic_temperature_exponent(): + def fget( self ): + return self._thermodynamic_temperature_exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument thermodynamic_temperature_exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._thermodynamic_temperature_exponent = REAL(value) + else: + self._thermodynamic_temperature_exponent = value + return property(**locals()) + + @apply + def amount_of_substance_exponent(): + def fget( self ): + return self._amount_of_substance_exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument amount_of_substance_exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._amount_of_substance_exponent = REAL(value) + else: + self._amount_of_substance_exponent = value + return property(**locals()) + + @apply + def luminous_intensity_exponent(): + def fget( self ): + return self._luminous_intensity_exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument luminous_intensity_exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._luminous_intensity_exponent = REAL(value) + else: + self._luminous_intensity_exponent = value + return property(**locals()) + +#################### + # ENTITY planar_pair # +#################### +class planar_pair(kinematic_pair): + '''Entity planar_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + +#################### + # ENTITY pre_defined_geometrical_tolerance_symbol # +#################### +class pre_defined_geometrical_tolerance_symbol(pre_defined_symbol): + '''Entity pre_defined_geometrical_tolerance_symbol definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_symbol.__init__(self , inherited0__name , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['angularity','basic dimension','blanked datum reference','circular runout','circularity','concentricity','cylindricity','datum target identification','diameter','filled datum reference','flatness','least material condition','maximum material condition','parallelism','perpendicularity','position','profile of a line','profile of a surface','projected tolerance zone','regardless of feature size','straightness','symmetry','total runout']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY symmetric_shape_aspect # +#################### +class symmetric_shape_aspect(shape_aspect): + '''Entity symmetric_shape_aspect definition. + + :param basis_relationships + :type basis_relationships:SET(1,None,'shape_aspect_relationship', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + + @apply + def basis_relationships(): + def fget( self ): + return self._basis_relationships + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument basis_relationships is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) >= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY directed_angle # +#################### +class directed_angle(shape_aspect): + '''Entity directed_angle definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (self.self.description == ['punch direction','profile normal','surface normal']) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY parallelism_tolerance # +#################### +class parallelism_tolerance(geometric_tolerance_with_datum_reference): + '''Entity parallelism_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ): + geometric_tolerance_with_datum_reference.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) < 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY externally_defined_character_glyph # +#################### +class externally_defined_character_glyph(externally_defined_item): + '''Entity externally_defined_character_glyph definition. + ''' + def __init__( self , inherited0__item_id , inherited1__source , ): + externally_defined_item.__init__(self , inherited0__item_id , inherited1__source , ) + +#################### + # ENTITY sliding_curve_pair # +#################### +class sliding_curve_pair(planar_curve_pair): + '''Entity sliding_curve_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__curve_1 , inherited6__curve_2 , inherited7__orientation , ): + planar_curve_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__curve_1 , inherited6__curve_2 , inherited7__orientation , ) + +#################### + # ENTITY characterized_class # +#################### +class characterized_class(characterized_object,class_): + '''Entity characterized_class definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__name , inherited3__description , ): + characterized_object.__init__(self , inherited0__name , inherited1__description , ) + class.__init__(self , inherited2__name , inherited3__description , ) + +#################### + # ENTITY externally_defined_tile_style # +#################### +class externally_defined_tile_style(externally_defined_item,geometric_representation_item): + '''Entity externally_defined_tile_style definition. + ''' + def __init__( self , inherited0__item_id , inherited1__source , inherited2__name , ): + externally_defined_item.__init__(self , inherited0__item_id , inherited1__source , ) + geometric_representation_item.__init__(self , inherited2__name , ) + +#################### + # ENTITY pre_defined_terminator_symbol # +#################### +class pre_defined_terminator_symbol(pre_defined_symbol): + '''Entity pre_defined_terminator_symbol definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_symbol.__init__(self , inherited0__name , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['blanked arrow','blanked box','blanked dot','dimension origin','filled arrow','filled box','filled dot','integral symbol','open arrow','slash','unfilled arrow']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY vector_style # +#################### +class vector_style(pre_defined_terminator_symbol,curve_style): + '''Entity vector_style definition. + ''' + def __init__( self , inherited0__name , inherited1__name , inherited2__curve_font , inherited3__curve_width , inherited4__curve_colour , ): + pre_defined_terminator_symbol.__init__(self , inherited0__name , ) + curve_style.__init__(self , inherited1__name , inherited2__curve_font , inherited3__curve_width , inherited4__curve_colour , ) + +#################### + # ENTITY time_interval_assignment # +#################### +class time_interval_assignment(BaseEntityClass): + '''Entity time_interval_assignment definition. + + :param assigned_time_interval + :type assigned_time_interval:time_interval + + :param role + :type role:time_interval_role + ''' + def __init__( self , assigned_time_interval,role, ): + self.assigned_time_interval = assigned_time_interval + self.role = role + + @apply + def assigned_time_interval(): + def fget( self ): + return self._assigned_time_interval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_time_interval is mantatory and can not be set to None') + if not check_type(value,time_interval): + self._assigned_time_interval = time_interval(value) + else: + self._assigned_time_interval = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,time_interval_role): + self._role = time_interval_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY applied_time_interval_assignment # +#################### +class applied_time_interval_assignment(time_interval_assignment): + '''Entity applied_time_interval_assignment definition. + + :param items + :type items:SET(1,None,'time_interval_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_time_interval , inherited1__role , items, ): + time_interval_assignment.__init__(self , inherited0__assigned_time_interval , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'time_interval_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY organizational_project_relationship # +#################### +class organizational_project_relationship(BaseEntityClass): + '''Entity organizational_project_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_organizational_project + :type relating_organizational_project:organizational_project + + :param related_organizational_project + :type related_organizational_project:organizational_project + ''' + def __init__( self , name,description,relating_organizational_project,related_organizational_project, ): + self.name = name + self.description = description + self.relating_organizational_project = relating_organizational_project + self.related_organizational_project = related_organizational_project + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_organizational_project(): + def fget( self ): + return self._relating_organizational_project + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_organizational_project is mantatory and can not be set to None') + if not check_type(value,organizational_project): + self._relating_organizational_project = organizational_project(value) + else: + self._relating_organizational_project = value + return property(**locals()) + + @apply + def related_organizational_project(): + def fget( self ): + return self._related_organizational_project + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_organizational_project is mantatory and can not be set to None') + if not check_type(value,organizational_project): + self._related_organizational_project = organizational_project(value) + else: + self._related_organizational_project = value + return property(**locals()) + +#################### + # ENTITY context_dependent_shape_representation # +#################### +class context_dependent_shape_representation(BaseEntityClass): + '''Entity context_dependent_shape_representation definition. + + :param representation_relation + :type representation_relation:shape_representation_relationship + + :param represented_product_relation + :type represented_product_relation:product_definition_shape + + :param description + :type description:text + + :param name + :type name:label + ''' + def __init__( self , representation_relation,represented_product_relation, ): + self.representation_relation = representation_relation + self.represented_product_relation = represented_product_relation + + @apply + def representation_relation(): + def fget( self ): + return self._representation_relation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_relation is mantatory and can not be set to None') + if not check_type(value,shape_representation_relationship): + self._representation_relation = shape_representation_relationship(value) + else: + self._representation_relation = value + return property(**locals()) + + @apply + def represented_product_relation(): + def fget( self ): + return self._represented_product_relation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument represented_product_relation is mantatory and can not be set to None') + if not check_type(value,product_definition_shape): + self._represented_product_relation = product_definition_shape(value) + else: + self._represented_product_relation = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_RELATIONSHIP' == TYPEOF(self.self.represented_product_relation.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY degenerate_toroidal_surface # +#################### +class degenerate_toroidal_surface(toroidal_surface): + '''Entity degenerate_toroidal_surface definition. + + :param select_outer + :type select_outer:BOOLEAN + ''' + def __init__( self , inherited0__name , inherited1__position , inherited2__major_radius , inherited3__minor_radius , select_outer, ): + toroidal_surface.__init__(self , inherited0__name , inherited1__position , inherited2__major_radius , inherited3__minor_radius , ) + self.select_outer = select_outer + + @apply + def select_outer(): + def fget( self ): + return self._select_outer + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument select_outer is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._select_outer = BOOLEAN(value) + else: + self._select_outer = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.major_radius < self.minor_radius) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY exp_function # +#################### +class exp_function(unary_function_call): + '''Entity exp_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY person_and_organization_assignment # +#################### +class person_and_organization_assignment(BaseEntityClass): + '''Entity person_and_organization_assignment definition. + + :param assigned_person_and_organization + :type assigned_person_and_organization:person_and_organization + + :param role + :type role:person_and_organization_role + ''' + def __init__( self , assigned_person_and_organization,role, ): + self.assigned_person_and_organization = assigned_person_and_organization + self.role = role + + @apply + def assigned_person_and_organization(): + def fget( self ): + return self._assigned_person_and_organization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_person_and_organization is mantatory and can not be set to None') + if not check_type(value,person_and_organization): + self._assigned_person_and_organization = person_and_organization(value) + else: + self._assigned_person_and_organization = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,person_and_organization_role): + self._role = person_and_organization_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY shape_aspect_associativity # +#################### +class shape_aspect_associativity(shape_aspect_relationship): + '''Entity shape_aspect_associativity definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ): + shape_aspect_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_shape_aspect , inherited3__related_shape_aspect , ) + def wr1(self): + eval_wr1_wr = self.self.relating_shape_aspect.self.product_definitional + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ( not self.self.related_shape_aspect.self.product_definitional) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY conditional_concept_feature # +#################### +class conditional_concept_feature(product_concept_feature): + '''Entity conditional_concept_feature definition. + + :param condition + :type condition:concept_feature_relationship_with_condition + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , condition, ): + product_concept_feature.__init__(self , inherited0__id , inherited1__name , inherited2__description , ) + self.condition = condition + + @apply + def condition(): + def fget( self ): + return self._condition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument condition is mantatory and can not be set to None') + if not check_type(value,concept_feature_relationship_with_condition): + self._condition = concept_feature_relationship_with_condition(value) + else: + self._condition = value + return property(**locals()) + +#################### + # ENTITY locator # +#################### +class locator(feature_definition): + '''Entity locator definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) <= 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) <= 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY presentation_style_assignment # +#################### +class presentation_style_assignment(founded_item): + '''Entity presentation_style_assignment definition. + + :param styles + :type styles:SET(1,None,'presentation_style_select', scope = schema_scope) + ''' + def __init__( self , styles, ): + founded_item.__init__(self , ) + self.styles = styles + + @apply + def styles(): + def fget( self ): + return self._styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'presentation_style_select', scope = schema_scope)): + self._styles = SET(value) + else: + self._styles = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) <= 2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY rib # +#################### +class rib(feature_definition): + '''Entity rib definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) <= 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) <= 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) <= 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY sql_mappable_defined_function # +#################### +class sql_mappable_defined_function(defined_function): + '''Entity sql_mappable_defined_function definition. + ''' + def __init__( self , ): + defined_function.__init__(self , ) + +#################### + # ENTITY face_outer_bound # +#################### +class face_outer_bound(face_bound): + '''Entity face_outer_bound definition. + ''' + def __init__( self , inherited0__name , inherited1__bound , inherited2__orientation , ): + face_bound.__init__(self , inherited0__name , inherited1__bound , inherited2__orientation , ) + +#################### + # ENTITY geometric_item_specific_usage # +#################### +class geometric_item_specific_usage(item_identified_representation_usage): + '''Entity geometric_item_specific_usage definition. + + :param item_identified_representation_usage_definition + :type item_identified_representation_usage_definition:shape_aspect + + :param item_identified_representation_usage_used_representation + :type item_identified_representation_usage_used_representation:shape_representation + + :param item_identified_representation_usage_identified_item + :type item_identified_representation_usage_identified_item:geometric_representation_item + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__definition , inherited3__used_representation , inherited4__identified_item , item_identified_representation_usage_definition,item_identified_representation_usage_used_representation,item_identified_representation_usage_identified_item, ): + item_identified_representation_usage.__init__(self , inherited0__name , inherited1__description , inherited2__definition , inherited3__used_representation , inherited4__identified_item , ) + self.item_identified_representation_usage_definition = item_identified_representation_usage_definition + self.item_identified_representation_usage_used_representation = item_identified_representation_usage_used_representation + self.item_identified_representation_usage_identified_item = item_identified_representation_usage_identified_item + + @apply + def item_identified_representation_usage_definition(): + def fget( self ): + return self._item_identified_representation_usage_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_identified_representation_usage_definition is mantatory and can not be set to None') + if not check_type(value,shape_aspect): + self._item_identified_representation_usage_definition = shape_aspect(value) + else: + self._item_identified_representation_usage_definition = value + return property(**locals()) + + @apply + def item_identified_representation_usage_used_representation(): + def fget( self ): + return self._item_identified_representation_usage_used_representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_identified_representation_usage_used_representation is mantatory and can not be set to None') + if not check_type(value,shape_representation): + self._item_identified_representation_usage_used_representation = shape_representation(value) + else: + self._item_identified_representation_usage_used_representation = value + return property(**locals()) + + @apply + def item_identified_representation_usage_identified_item(): + def fget( self ): + return self._item_identified_representation_usage_identified_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_identified_representation_usage_identified_item is mantatory and can not be set to None') + if not check_type(value,geometric_representation_item): + self._item_identified_representation_usage_identified_item = geometric_representation_item(value) + else: + self._item_identified_representation_usage_identified_item = value + return property(**locals()) + +#################### + # ENTITY mass_measure_with_unit # +#################### +class mass_measure_with_unit(measure_with_unit): + '''Entity mass_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.MASS_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY square_root_function # +#################### +class square_root_function(unary_function_call): + '''Entity square_root_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY surface_texture_representation # +#################### +class surface_texture_representation(representation): + '''Entity surface_texture_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(None) == 1) and (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) > 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.REPRESENTATION_RELATIONSHIP.REP_1')) <= 1) and (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.REPRESENTATION_RELATIONSHIP.REP_2')) == 0)) and (SIZEOF(None) == SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.REPRESENTATION_RELATIONSHIP.REP_1')))) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.USED_REPRESENTATION')) == 1) and (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY and_expression # +#################### +class and_expression(multiple_arity_boolean_expression): + '''Entity and_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ): + multiple_arity_boolean_expression.__init__(self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ) + +#################### + # ENTITY brep_with_voids # +#################### +class brep_with_voids(manifold_solid_brep): + '''Entity brep_with_voids definition. + + :param voids + :type voids:SET(1,None,'oriented_closed_shell', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__outer , voids, ): + manifold_solid_brep.__init__(self , inherited0__name , inherited1__outer , ) + self.voids = voids + + @apply + def voids(): + def fget( self ): + return self._voids + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument voids is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'oriented_closed_shell', scope = schema_scope)): + self._voids = SET(value) + else: + self._voids = value + return property(**locals()) + +#################### + # ENTITY datum_target # +#################### +class datum_target(shape_aspect): + '''Entity datum_target definition. + + :param target_id + :type target_id:identifier + + :param target_basis_relationship + :type target_basis_relationship:shape_aspect_relationship + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , target_id, ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + self.target_id = target_id + + @apply + def target_id(): + def fget( self ): + return self._target_id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument target_id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._target_id = identifier(value) + else: + self._target_id = value + return property(**locals()) + + @apply + def target_basis_relationship(): + def fget( self ): + return self._target_basis_relationship + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument target_basis_relationship is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.shape_aspect.self.product_definitional == TRUE) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY surface_style_usage # +#################### +class surface_style_usage(founded_item): + '''Entity surface_style_usage definition. + + :param side + :type side:surface_side + + :param style + :type style:surface_side_style_select + ''' + def __init__( self , side,style, ): + founded_item.__init__(self , ) + self.side = side + self.style = style + + @apply + def side(): + def fget( self ): + return self._side + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument side is mantatory and can not be set to None') + if not check_type(value,surface_side): + self._side = surface_side(value) + else: + self._side = value + return property(**locals()) + + @apply + def style(): + def fget( self ): + return self._style + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument style is mantatory and can not be set to None') + if not check_type(value,surface_side_style_select): + self._style = surface_side_style_select(value) + else: + self._style = value + return property(**locals()) + +#################### + # ENTITY thermodynamic_temperature_unit # +#################### +class thermodynamic_temperature_unit(named_unit): + '''Entity thermodynamic_temperature_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 0) and (self.self.named_unit.self.dimensions.self.mass_exponent == 0)) and (self.self.named_unit.self.dimensions.self.time_exponent == 0)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 0)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 1)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 0)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_ineffectivity_assignment # +#################### +class applied_ineffectivity_assignment(effectivity_assignment): + '''Entity applied_ineffectivity_assignment definition. + + :param items + :type items:SET(1,None,'effectivity_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_effectivity , items, ): + effectivity_assignment.__init__(self , inherited0__assigned_effectivity , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'effectivity_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'LOT_EFFECTIVITY','AUTOMOTIVE_DESIGN.' + 'SERIAL_NUMBERED_EFFECTIVITY','AUTOMOTIVE_DESIGN.' + 'PRODUCT_DEFINITION_EFFECTIVITY'] * TYPEOF(self.self.assigned_effectivity)) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY composite_text_with_blanking_box # +#################### +class composite_text_with_blanking_box(composite_text): + '''Entity composite_text_with_blanking_box definition. + + :param blanking + :type blanking:planar_box + ''' + def __init__( self , inherited0__name , inherited1__collected_text , blanking, ): + composite_text.__init__(self , inherited0__name , inherited1__collected_text , ) + self.blanking = blanking + + @apply + def blanking(): + def fget( self ): + return self._blanking + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument blanking is mantatory and can not be set to None') + if not check_type(value,planar_box): + self._blanking = planar_box(value) + else: + self._blanking = value + return property(**locals()) + +#################### + # ENTITY datum_feature_callout # +#################### +class datum_feature_callout(draughting_callout): + '''Entity datum_feature_callout definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + +#################### + # ENTITY organization_role # +#################### +class organization_role(BaseEntityClass): + '''Entity organization_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY point_on_curve # +#################### +class point_on_curve(point): + '''Entity point_on_curve definition. + + :param basis_curve + :type basis_curve:curve + + :param point_parameter + :type point_parameter:parameter_value + ''' + def __init__( self , inherited0__name , basis_curve,point_parameter, ): + point.__init__(self , inherited0__name , ) + self.basis_curve = basis_curve + self.point_parameter = point_parameter + + @apply + def basis_curve(): + def fget( self ): + return self._basis_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_curve is mantatory and can not be set to None') + if not check_type(value,curve): + self._basis_curve = curve(value) + else: + self._basis_curve = value + return property(**locals()) + + @apply + def point_parameter(): + def fget( self ): + return self._point_parameter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument point_parameter is mantatory and can not be set to None') + if not check_type(value,parameter_value): + self._point_parameter = parameter_value(value) + else: + self._point_parameter = value + return property(**locals()) + +#################### + # ENTITY surface_style_rendering_with_properties # +#################### +class surface_style_rendering_with_properties(surface_style_rendering): + '''Entity surface_style_rendering_with_properties definition. + + :param properties + :type properties:SET(1,2,'rendering_properties_select', scope = schema_scope) + ''' + def __init__( self , inherited0__rendering_method , inherited1__surface_colour , properties, ): + surface_style_rendering.__init__(self , inherited0__rendering_method , inherited1__surface_colour , ) + self.properties = properties + + @apply + def properties(): + def fget( self ): + return self._properties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument properties is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'rendering_properties_select', scope = schema_scope)): + self._properties = SET(value) + else: + self._properties = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((HIINDEX(self.self.properties) == 1) XOR (TYPEOF(self.self.properties[1]) != TYPEOF(self.self.properties[2]))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY default_tolerance_table_cell # +#################### +class default_tolerance_table_cell(compound_representation_item): + '''Entity default_tolerance_table_cell definition. + ''' + def __init__( self , inherited0__name , inherited1__item_element , ): + compound_representation_item.__init__(self , inherited0__name , inherited1__item_element , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = default_tolerance_table_cell_wr2(self.self.compound_representation_item.self.item_element) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = default_tolerance_table_cell_wr3(self.self.compound_representation_item.self.item_element) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = default_tolerance_table_cell_wr4(self.self.compound_representation_item.self.item_element) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = default_tolerance_table_cell_wr5(self.self.compound_representation_item.self.item_element) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY dimension_curve_directed_callout # +#################### +class dimension_curve_directed_callout(draughting_callout): + '''Entity dimension_curve_directed_callout definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(self.self.draughting_callout.self.contents) >= 2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY diameter_dimension # +#################### +class diameter_dimension(dimension_curve_directed_callout): + '''Entity diameter_dimension definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + dimension_curve_directed_callout.__init__(self , inherited0__name , inherited1__contents , ) + +#################### + # ENTITY rolling_surface_pair # +#################### +class rolling_surface_pair(surface_pair): + '''Entity rolling_surface_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__surface_1 , inherited6__surface_2 , inherited7__orientation , ): + surface_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__surface_1 , inherited6__surface_2 , inherited7__orientation , ) + +#################### + # ENTITY total_runout_tolerance # +#################### +class total_runout_tolerance(geometric_tolerance_with_datum_reference): + '''Entity total_runout_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ): + geometric_tolerance_with_datum_reference.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) <= 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_definition_context_role # +#################### +class product_definition_context_role(BaseEntityClass): + '''Entity product_definition_context_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY revolute_pair # +#################### +class revolute_pair(kinematic_pair): + '''Entity revolute_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + +#################### + # ENTITY screw_pair_value # +#################### +class screw_pair_value(pair_value): + '''Entity screw_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:screw_pair + + :param actual_rotation + :type actual_rotation:plane_angle_measure + + :param actual_translation + :type actual_translation:length_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_rotation, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_rotation = actual_rotation + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,screw_pair): + self._pair_value_applies_to_pair = screw_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_rotation(): + def fget( self ): + return self._actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_rotation is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._actual_rotation = plane_angle_measure(value) + else: + self._actual_rotation = value + return property(**locals()) + + @apply + def actual_translation(): + def fget( self ): + attribute_eval = (((self.self.pair_value.self.applies_to_pair.self.screw_pair.self.pitch * plane_angle_for_pair_in_radian(self.self.pair_value.self.applies_to_pair,self.actual_rotation)) / 2) * PI ) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument actual_translation is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY text_literal_with_associated_curves # +#################### +class text_literal_with_associated_curves(text_literal): + '''Entity text_literal_with_associated_curves definition. + + :param associated_curves + :type associated_curves:SET(1,None,'curve', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , associated_curves, ): + text_literal.__init__(self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , ) + self.associated_curves = associated_curves + + @apply + def associated_curves(): + def fget( self ): + return self._associated_curves + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument associated_curves is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'curve', scope = schema_scope)): + self._associated_curves = SET(value) + else: + self._associated_curves = value + return property(**locals()) + +#################### + # ENTITY face_surface # +#################### +class face_surface(face,geometric_representation_item): + '''Entity face_surface definition. + + :param face_geometry + :type face_geometry:surface + + :param same_sense + :type same_sense:BOOLEAN + ''' + def __init__( self , inherited0__name , inherited1__bounds , inherited2__name , face_geometry,same_sense, ): + face.__init__(self , inherited0__name , inherited1__bounds , ) + geometric_representation_item.__init__(self , inherited2__name , ) + self.face_geometry = face_geometry + self.same_sense = same_sense + + @apply + def face_geometry(): + def fget( self ): + return self._face_geometry + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument face_geometry is mantatory and can not be set to None') + if not check_type(value,surface): + self._face_geometry = surface(value) + else: + self._face_geometry = value + return property(**locals()) + + @apply + def same_sense(): + def fget( self ): + return self._same_sense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument same_sense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._same_sense = BOOLEAN(value) + else: + self._same_sense = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('AUTOMOTIVE_DESIGN.ORIENTED_SURFACE' == TYPEOF(self.face_geometry))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY material_property # +#################### +class material_property(property_definition): + '''Entity material_property definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__definition , ): + property_definition.__init__(self , inherited0__name , inherited1__description , inherited2__definition , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.CHARACTERIZED_OBJECT' == TYPEOF(self.self.property_definition.self.definition)) or (SIZEOF(bag_to_set(USEDIN(self,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')) - None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY oriented_face # +#################### +class oriented_face(face): + '''Entity oriented_face definition. + + :param face_element + :type face_element:face + + :param orientation + :type orientation:BOOLEAN + + :param face_bounds + :type face_bounds:SET(1,None,'face_bound', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__bounds , face_element,orientation, ): + face.__init__(self , inherited0__name , inherited1__bounds , ) + self.face_element = face_element + self.orientation = orientation + + @apply + def face_element(): + def fget( self ): + return self._face_element + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument face_element is mantatory and can not be set to None') + if not check_type(value,face): + self._face_element = face(value) + else: + self._face_element = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def face_bounds(): + def fget( self ): + attribute_eval = conditional_reverse(self.self.orientation,self.self.face_element.self.bounds) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument face_bounds is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('AUTOMOTIVE_DESIGN.ORIENTED_FACE' == TYPEOF(self.self.face_element))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY surface_of_revolution # +#################### +class surface_of_revolution(swept_surface): + '''Entity surface_of_revolution definition. + + :param axis_position + :type axis_position:axis1_placement + + :param axis_line + :type axis_line:line + ''' + def __init__( self , inherited0__name , inherited1__swept_curve , axis_position, ): + swept_surface.__init__(self , inherited0__name , inherited1__swept_curve , ) + self.axis_position = axis_position + + @apply + def axis_position(): + def fget( self ): + return self._axis_position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axis_position is mantatory and can not be set to None') + if not check_type(value,axis1_placement): + self._axis_position = axis1_placement(value) + else: + self._axis_position = value + return property(**locals()) + + @apply + def axis_line(): + def fget( self ): + attribute_eval = (((representation_item('') == geometric_representation_item()) == curve()) == line(self.axis_position.self.location,(representation_item('') == geometric_representation_item()) == vector(self.axis_position.self.z,1))) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument axis_line is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY angular_size # +#################### +class angular_size(dimensional_size): + '''Entity angular_size definition. + + :param angle_selection + :type angle_selection:angle_relator + ''' + def __init__( self , inherited0__applies_to , inherited1__name , angle_selection, ): + dimensional_size.__init__(self , inherited0__applies_to , inherited1__name , ) + self.angle_selection = angle_selection + + @apply + def angle_selection(): + def fget( self ): + return self._angle_selection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument angle_selection is mantatory and can not be set to None') + if not check_type(value,angle_relator): + self._angle_selection = angle_relator(value) + else: + self._angle_selection = value + return property(**locals()) + +#################### + # ENTITY organizational_project_assignment # +#################### +class organizational_project_assignment(BaseEntityClass): + '''Entity organizational_project_assignment definition. + + :param assigned_organizational_project + :type assigned_organizational_project:organizational_project + + :param role + :type role:organizational_project_role + ''' + def __init__( self , assigned_organizational_project,role, ): + self.assigned_organizational_project = assigned_organizational_project + self.role = role + + @apply + def assigned_organizational_project(): + def fget( self ): + return self._assigned_organizational_project + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_organizational_project is mantatory and can not be set to None') + if not check_type(value,organizational_project): + self._assigned_organizational_project = organizational_project(value) + else: + self._assigned_organizational_project = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,organizational_project_role): + self._role = organizational_project_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY applied_organizational_project_assignment # +#################### +class applied_organizational_project_assignment(organizational_project_assignment): + '''Entity applied_organizational_project_assignment definition. + + :param items + :type items:SET(1,None,'organizational_project_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_organizational_project , inherited1__role , items, ): + organizational_project_assignment.__init__(self , inherited0__assigned_organizational_project , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'organizational_project_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY product_identification # +#################### +class product_identification(configuration_item,characterized_object): + '''Entity product_identification definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__item_concept , inherited4__purpose , inherited5__name , inherited6__description , ): + configuration_item.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__item_concept , inherited4__purpose , ) + characterized_object.__init__(self , inherited5__name , inherited6__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (('AUTOMOTIVE_DESIGN.' + 'PRODUCT_CLASS') == TYPEOF(self.self.item_concept)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'CONFIGURABLE_ITEM') == TYPEOF(self))) or (('AUTOMOTIVE_DESIGN.' + 'PRODUCT_SPECIFICATION') == TYPEOF(self))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY product_specification # +#################### +class product_specification(product_identification,configurable_item): + '''Entity product_specification definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__item_concept , inherited4__purpose , inherited5__name , inherited6__description , inherited7__id , inherited8__name , inherited9__description , inherited10__item_concept , inherited11__purpose , inherited12__item_concept_feature , ): + product_identification.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__item_concept , inherited4__purpose , inherited5__name , inherited6__description , ) + configurable_item.__init__(self , inherited7__id , inherited8__name , inherited9__description , inherited10__item_concept , inherited11__purpose , inherited12__item_concept_feature , ) + +#################### + # ENTITY advanced_brep_shape_representation # +#################### +class advanced_brep_shape_representation(shape_representation): + '''Entity advanced_brep_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + +#################### + # ENTITY cylindrical_pair_value # +#################### +class cylindrical_pair_value(pair_value): + '''Entity cylindrical_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:cylindrical_pair + + :param actual_translation + :type actual_translation:length_measure + + :param actual_rotation + :type actual_rotation:plane_angle_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_translation,actual_rotation, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_translation = actual_translation + self.actual_rotation = actual_rotation + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,cylindrical_pair): + self._pair_value_applies_to_pair = cylindrical_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_translation(): + def fget( self ): + return self._actual_translation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_translation is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._actual_translation = length_measure(value) + else: + self._actual_translation = value + return property(**locals()) + + @apply + def actual_rotation(): + def fget( self ): + return self._actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_rotation is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._actual_rotation = plane_angle_measure(value) + else: + self._actual_rotation = value + return property(**locals()) + +#################### + # ENTITY comparison_not_equal # +#################### +class comparison_not_equal(comparison_expression): + '''Entity comparison_not_equal definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + comparison_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY property_definition_relationship # +#################### +class property_definition_relationship(BaseEntityClass): + '''Entity property_definition_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_property_definition + :type relating_property_definition:property_definition + + :param related_property_definition + :type related_property_definition:property_definition + ''' + def __init__( self , name,description,relating_property_definition,related_property_definition, ): + self.name = name + self.description = description + self.relating_property_definition = relating_property_definition + self.related_property_definition = related_property_definition + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def relating_property_definition(): + def fget( self ): + return self._relating_property_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_property_definition is mantatory and can not be set to None') + if not check_type(value,property_definition): + self._relating_property_definition = property_definition(value) + else: + self._relating_property_definition = value + return property(**locals()) + + @apply + def related_property_definition(): + def fget( self ): + return self._related_property_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_property_definition is mantatory and can not be set to None') + if not check_type(value,property_definition): + self._related_property_definition = property_definition(value) + else: + self._related_property_definition = value + return property(**locals()) + +#################### + # ENTITY edge_curve # +#################### +class edge_curve(edge,geometric_representation_item): + '''Entity edge_curve definition. + + :param edge_geometry + :type edge_geometry:curve + + :param same_sense + :type same_sense:BOOLEAN + ''' + def __init__( self , inherited0__name , inherited1__edge_start , inherited2__edge_end , inherited3__name , edge_geometry,same_sense, ): + edge.__init__(self , inherited0__name , inherited1__edge_start , inherited2__edge_end , ) + geometric_representation_item.__init__(self , inherited3__name , ) + self.edge_geometry = edge_geometry + self.same_sense = same_sense + + @apply + def edge_geometry(): + def fget( self ): + return self._edge_geometry + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edge_geometry is mantatory and can not be set to None') + if not check_type(value,curve): + self._edge_geometry = curve(value) + else: + self._edge_geometry = value + return property(**locals()) + + @apply + def same_sense(): + def fget( self ): + return self._same_sense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument same_sense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._same_sense = BOOLEAN(value) + else: + self._same_sense = value + return property(**locals()) + +#################### + # ENTITY kinematic_property_definition # +#################### +class kinematic_property_definition(property_definition): + '''Entity kinematic_property_definition definition. + + :param ground_definition + :type ground_definition:characterized_definition + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__definition , ground_definition, ): + property_definition.__init__(self , inherited0__name , inherited1__description , inherited2__definition , ) + self.ground_definition = ground_definition + + @apply + def ground_definition(): + def fget( self ): + return self._ground_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ground_definition is mantatory and can not be set to None') + if not check_type(value,characterized_definition): + self._ground_definition = characterized_definition(value) + else: + self._ground_definition = value + return property(**locals()) + +#################### + # ENTITY radius_dimension # +#################### +class radius_dimension(dimension_curve_directed_callout): + '''Entity radius_dimension definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + dimension_curve_directed_callout.__init__(self , inherited0__name , inherited1__contents , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY sliding_surface_pair_value # +#################### +class sliding_surface_pair_value(pair_value): + '''Entity sliding_surface_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:sliding_surface_pair + + :param actual_point_on_surface_1 + :type actual_point_on_surface_1:point_on_surface + + :param actual_point_on_surface_2 + :type actual_point_on_surface_2:point_on_surface + + :param actual_rotation + :type actual_rotation:plane_angle_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_point_on_surface_1,actual_point_on_surface_2,actual_rotation, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_point_on_surface_1 = actual_point_on_surface_1 + self.actual_point_on_surface_2 = actual_point_on_surface_2 + self.actual_rotation = actual_rotation + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,sliding_surface_pair): + self._pair_value_applies_to_pair = sliding_surface_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_point_on_surface_1(): + def fget( self ): + return self._actual_point_on_surface_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_point_on_surface_1 is mantatory and can not be set to None') + if not check_type(value,point_on_surface): + self._actual_point_on_surface_1 = point_on_surface(value) + else: + self._actual_point_on_surface_1 = value + return property(**locals()) + + @apply + def actual_point_on_surface_2(): + def fget( self ): + return self._actual_point_on_surface_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_point_on_surface_2 is mantatory and can not be set to None') + if not check_type(value,point_on_surface): + self._actual_point_on_surface_2 = point_on_surface(value) + else: + self._actual_point_on_surface_2 = value + return property(**locals()) + + @apply + def actual_rotation(): + def fget( self ): + return self._actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_rotation is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._actual_rotation = plane_angle_measure(value) + else: + self._actual_rotation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.pair_value.self.applies_to_pair.self.surface_pair.self.surface_1 == self.actual_point_on_surface_1.self.basis_surface) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.pair_value.self.applies_to_pair.self.surface_pair.self.surface_2 == self.actual_point_on_surface_2.self.basis_surface) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY action_property # +#################### +class action_property(BaseEntityClass): + '''Entity action_property definition. + + :param name + :type name:label + + :param description + :type description:text + + :param definition + :type definition:characterized_action_definition + ''' + def __init__( self , name,description,definition, ): + self.name = name + self.description = description + self.definition = definition + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definition is mantatory and can not be set to None') + if not check_type(value,characterized_action_definition): + self._definition = characterized_action_definition(value) + else: + self._definition = value + return property(**locals()) + +#################### + # ENTITY electric_current_measure_with_unit # +#################### +class electric_current_measure_with_unit(measure_with_unit): + '''Entity electric_current_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.ELECTRIC_CURRENT_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY gear_pair_range # +#################### +class gear_pair_range(simple_pair_range): + '''Entity gear_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:gear_pair + + :param lower_limit_actual_rotation_1 + :type lower_limit_actual_rotation_1:rotational_range_measure + + :param upper_limit_actual_rotation_1 + :type upper_limit_actual_rotation_1:rotational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,lower_limit_actual_rotation_1,upper_limit_actual_rotation_1, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.lower_limit_actual_rotation_1 = lower_limit_actual_rotation_1 + self.upper_limit_actual_rotation_1 = upper_limit_actual_rotation_1 + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,gear_pair): + self._simple_pair_range_applies_to_pair = gear_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def lower_limit_actual_rotation_1(): + def fget( self ): + return self._lower_limit_actual_rotation_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_rotation_1 is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_actual_rotation_1 = rotational_range_measure(value) + else: + self._lower_limit_actual_rotation_1 = value + return property(**locals()) + + @apply + def upper_limit_actual_rotation_1(): + def fget( self ): + return self._upper_limit_actual_rotation_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_rotation_1 is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_actual_rotation_1 = rotational_range_measure(value) + else: + self._upper_limit_actual_rotation_1 = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_rotation_1)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_rotation_1))) XOR (self.lower_limit_actual_rotation_1 < self.upper_limit_actual_rotation_1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY boxed_half_space # +#################### +class boxed_half_space(half_space_solid): + '''Entity boxed_half_space definition. + + :param enclosure + :type enclosure:box_domain + ''' + def __init__( self , inherited0__name , inherited1__base_surface , inherited2__agreement_flag , enclosure, ): + half_space_solid.__init__(self , inherited0__name , inherited1__base_surface , inherited2__agreement_flag , ) + self.enclosure = enclosure + + @apply + def enclosure(): + def fget( self ): + return self._enclosure + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument enclosure is mantatory and can not be set to None') + if not check_type(value,box_domain): + self._enclosure = box_domain(value) + else: + self._enclosure = value + return property(**locals()) + +#################### + # ENTITY product_definition_process # +#################### +class product_definition_process(action): + '''Entity product_definition_process definition. + + :param identification + :type identification:identifier + + :param product_definitions + :type product_definitions:SET(1,None,'process_product_association', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__chosen_method , identification, ): + action.__init__(self , inherited0__name , inherited1__description , inherited2__chosen_method , ) + self.identification = identification + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument identification is mantatory and can not be set to None') + if not check_type(value,identifier): + self._identification = identifier(value) + else: + self._identification = value + return property(**locals()) + + @apply + def product_definitions(): + def fget( self ): + return self._product_definitions + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument product_definitions is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY product_process_plan # +#################### +class product_process_plan(product_definition_process): + '''Entity product_process_plan definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__chosen_method , inherited3__identification , ): + product_definition_process.__init__(self , inherited0__name , inherited1__description , inherited2__chosen_method , inherited3__identification , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ACTION_RELATIONSHIP.RELATING_ACTION'))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY document_product_association # +#################### +class document_product_association(BaseEntityClass): + '''Entity document_product_association definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_document + :type relating_document:document + + :param related_product + :type related_product:product_or_formation_or_definition + ''' + def __init__( self , name,description,relating_document,related_product, ): + self.name = name + self.description = description + self.relating_document = relating_document + self.related_product = related_product + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_document(): + def fget( self ): + return self._relating_document + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_document is mantatory and can not be set to None') + if not check_type(value,document): + self._relating_document = document(value) + else: + self._relating_document = value + return property(**locals()) + + @apply + def related_product(): + def fget( self ): + return self._related_product + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_product is mantatory and can not be set to None') + if not check_type(value,product_or_formation_or_definition): + self._related_product = product_or_formation_or_definition(value) + else: + self._related_product = value + return property(**locals()) + +#################### + # ENTITY document_product_equivalence # +#################### +class document_product_equivalence(document_product_association): + '''Entity document_product_equivalence definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_document , inherited3__related_product , ): + document_product_association.__init__(self , inherited0__name , inherited1__description , inherited2__relating_document , inherited3__related_product , ) + def wr1(self): + eval_wr1_wr = (self.self.name == 'equivalence') + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'PRODUCT') == TYPEOF(self.self.related_product))) or ((self.self.relating_document.self.kind.self.product_data_type == 'configuration controlled document') and (SIZEOF(None) == 1))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'PRODUCT_DEFINITION_FORMATION') == TYPEOF(self.self.related_product))) or ((self.self.relating_document.self.kind.self.product_data_type == 'configuration controlled document version') and (SIZEOF(None) == 1))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'PRODUCT_DEFINITION') == TYPEOF(self.self.related_product))) or ((self.self.relating_document.self.kind.self.product_data_type == 'configuration controlled document definition') and (SIZEOF(None) == 1))) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY point_replica # +#################### +class point_replica(point): + '''Entity point_replica definition. + + :param parent_pt + :type parent_pt:point + + :param transformation + :type transformation:cartesian_transformation_operator + ''' + def __init__( self , inherited0__name , parent_pt,transformation, ): + point.__init__(self , inherited0__name , ) + self.parent_pt = parent_pt + self.transformation = transformation + + @apply + def parent_pt(): + def fget( self ): + return self._parent_pt + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parent_pt is mantatory and can not be set to None') + if not check_type(value,point): + self._parent_pt = point(value) + else: + self._parent_pt = value + return property(**locals()) + + @apply + def transformation(): + def fget( self ): + return self._transformation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transformation is mantatory and can not be set to None') + if not check_type(value,cartesian_transformation_operator): + self._transformation = cartesian_transformation_operator(value) + else: + self._transformation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.transformation.self.dim == self.parent_pt.self.dim) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = acyclic_point_replica(self,self.parent_pt) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY product # +#################### +class product(BaseEntityClass): + '''Entity product definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + + :param frame_of_reference + :type frame_of_reference:SET(1,None,'product_context', scope = schema_scope) + ''' + def __init__( self , id,name,description,frame_of_reference, ): + self.id = id + self.name = name + self.description = description + self.frame_of_reference = frame_of_reference + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def frame_of_reference(): + def fget( self ): + return self._frame_of_reference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument frame_of_reference is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'product_context', scope = schema_scope)): + self._frame_of_reference = SET(value) + else: + self._frame_of_reference = value + return property(**locals()) + +#################### + # ENTITY product_definition_context_association # +#################### +class product_definition_context_association(BaseEntityClass): + '''Entity product_definition_context_association definition. + + :param definition + :type definition:product_definition + + :param frame_of_reference + :type frame_of_reference:product_definition_context + + :param role + :type role:product_definition_context_role + ''' + def __init__( self , definition,frame_of_reference,role, ): + self.definition = definition + self.frame_of_reference = frame_of_reference + self.role = role + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definition is mantatory and can not be set to None') + if not check_type(value,product_definition): + self._definition = product_definition(value) + else: + self._definition = value + return property(**locals()) + + @apply + def frame_of_reference(): + def fget( self ): + return self._frame_of_reference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument frame_of_reference is mantatory and can not be set to None') + if not check_type(value,product_definition_context): + self._frame_of_reference = product_definition_context(value) + else: + self._frame_of_reference = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,product_definition_context_role): + self._role = product_definition_context_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY datum_reference # +#################### +class datum_reference(BaseEntityClass): + '''Entity datum_reference definition. + + :param precedence + :type precedence:INTEGER + + :param referenced_datum + :type referenced_datum:datum + ''' + def __init__( self , precedence,referenced_datum, ): + self.precedence = precedence + self.referenced_datum = referenced_datum + + @apply + def precedence(): + def fget( self ): + return self._precedence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument precedence is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._precedence = INTEGER(value) + else: + self._precedence = value + return property(**locals()) + + @apply + def referenced_datum(): + def fget( self ): + return self._referenced_datum + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument referenced_datum is mantatory and can not be set to None') + if not check_type(value,datum): + self._referenced_datum = datum(value) + else: + self._referenced_datum = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.precedence > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY rectangular_trimmed_surface # +#################### +class rectangular_trimmed_surface(bounded_surface): + '''Entity rectangular_trimmed_surface definition. + + :param basis_surface + :type basis_surface:surface + + :param u1 + :type u1:parameter_value + + :param u2 + :type u2:parameter_value + + :param v1 + :type v1:parameter_value + + :param v2 + :type v2:parameter_value + + :param usense + :type usense:BOOLEAN + + :param vsense + :type vsense:BOOLEAN + ''' + def __init__( self , inherited0__name , basis_surface,u1,u2,v1,v2,usense,vsense, ): + bounded_surface.__init__(self , inherited0__name , ) + self.basis_surface = basis_surface + self.u1 = u1 + self.u2 = u2 + self.v1 = v1 + self.v2 = v2 + self.usense = usense + self.vsense = vsense + + @apply + def basis_surface(): + def fget( self ): + return self._basis_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._basis_surface = surface(value) + else: + self._basis_surface = value + return property(**locals()) + + @apply + def u1(): + def fget( self ): + return self._u1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u1 is mantatory and can not be set to None') + if not check_type(value,parameter_value): + self._u1 = parameter_value(value) + else: + self._u1 = value + return property(**locals()) + + @apply + def u2(): + def fget( self ): + return self._u2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u2 is mantatory and can not be set to None') + if not check_type(value,parameter_value): + self._u2 = parameter_value(value) + else: + self._u2 = value + return property(**locals()) + + @apply + def v1(): + def fget( self ): + return self._v1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v1 is mantatory and can not be set to None') + if not check_type(value,parameter_value): + self._v1 = parameter_value(value) + else: + self._v1 = value + return property(**locals()) + + @apply + def v2(): + def fget( self ): + return self._v2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v2 is mantatory and can not be set to None') + if not check_type(value,parameter_value): + self._v2 = parameter_value(value) + else: + self._v2 = value + return property(**locals()) + + @apply + def usense(): + def fget( self ): + return self._usense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument usense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._usense = BOOLEAN(value) + else: + self._usense = value + return property(**locals()) + + @apply + def vsense(): + def fget( self ): + return self._vsense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vsense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._vsense = BOOLEAN(value) + else: + self._vsense = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.u1 != self.u2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.v1 != self.v2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (((('AUTOMOTIVE_DESIGN.ELEMENTARY_SURFACE' == TYPEOF(self.basis_surface)) and ( not ('AUTOMOTIVE_DESIGN.PLANE' == TYPEOF(self.basis_surface)))) or ('AUTOMOTIVE_DESIGN.SURFACE_OF_REVOLUTION' == TYPEOF(self.basis_surface))) or (self.usense == (self.u2 > self.u1))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((('AUTOMOTIVE_DESIGN.SPHERICAL_SURFACE' == TYPEOF(self.basis_surface)) or ('AUTOMOTIVE_DESIGN.TOROIDAL_SURFACE' == TYPEOF(self.basis_surface))) or (self.vsense == (self.v2 > self.v1))) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY simple_string_expression # +#################### +class simple_string_expression(string_expression,simple_generic_expression): + '''Entity simple_string_expression definition. + ''' + def __init__( self , ): + string_expression.__init__(self , ) + simple_generic_expression.__init__(self , ) + +#################### + # ENTITY string_variable # +#################### +class string_variable(simple_string_expression,variable): + '''Entity string_variable definition. + ''' + def __init__( self , ): + simple_string_expression.__init__(self , ) + variable.__init__(self , ) + +#################### + # ENTITY id_attribute # +#################### +class id_attribute(BaseEntityClass): + '''Entity id_attribute definition. + + :param attribute_value + :type attribute_value:identifier + + :param identified_item + :type identified_item:id_attribute_select + ''' + def __init__( self , attribute_value,identified_item, ): + self.attribute_value = attribute_value + self.identified_item = identified_item + + @apply + def attribute_value(): + def fget( self ): + return self._attribute_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument attribute_value is mantatory and can not be set to None') + if not check_type(value,identifier): + self._attribute_value = identifier(value) + else: + self._attribute_value = value + return property(**locals()) + + @apply + def identified_item(): + def fget( self ): + return self._identified_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument identified_item is mantatory and can not be set to None') + if not check_type(value,id_attribute_select): + self._identified_item = id_attribute_select(value) + else: + self._identified_item = value + return property(**locals()) + +#################### + # ENTITY language # +#################### +class language(group): + '''Entity language definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + group.__init__(self , inherited0__name , inherited1__description , ) + +#################### + # ENTITY plane # +#################### +class plane(elementary_surface): + '''Entity plane definition. + ''' + def __init__( self , inherited0__name , inherited1__position , ): + elementary_surface.__init__(self , inherited0__name , inherited1__position , ) + +#################### + # ENTITY pocket_bottom # +#################### +class pocket_bottom(shape_aspect): + '''Entity pocket_bottom definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.description == ['planar','complex','through']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not (self.self.description == ['planar','complex'])) or ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (self.self.description == ['planar','complex'])) or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'complex') or ((SIZEOF(None) == 1) and (SIZEOF(None) == 1))) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'planar') or ((SIZEOF(None) == 1) and (SIZEOF(None) == 1))) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((self.self.description != 'planar') or ((SIZEOF(None) == 1) and (SIZEOF(None) == 1))) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((self.self.description != 'through') or (SIZEOF(None) == 0)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = ((SIZEOF(None) == 1) and (SIZEOF(None) == 1)) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + +#################### + # ENTITY annotation_plane # +#################### +class annotation_plane(annotation_occurrence,geometric_representation_item): + '''Entity annotation_plane definition. + + :param elements + :type elements:SET(1,None,'annotation_plane_element', scope = schema_scope) + + :param styled_item_item + :type styled_item_item:plane_or_planar_box + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__name , elements,styled_item_item, ): + annotation_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , ) + geometric_representation_item.__init__(self , inherited3__name , ) + self.elements = elements + self.styled_item_item = styled_item_item + + @apply + def elements(): + def fget( self ): + return self._elements + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'annotation_plane_element', scope = schema_scope)): + self._elements = SET(value) + else: + self._elements = value + else: + self._elements = value + return property(**locals()) + + @apply + def styled_item_item(): + def fget( self ): + return self._styled_item_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styled_item_item is mantatory and can not be set to None') + if not check_type(value,plane_or_planar_box): + self._styled_item_item = plane_or_planar_box(value) + else: + self._styled_item_item = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.geometric_representation_item.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'PLANAR_BOX') == TYPEOF(self.self.styled_item.self.item))) or (('AUTOMOTIVE_DESIGN.' + 'AXIS2_PLACEMENT_3D') == TYPEOF(self.self.styled_item.self.item.self.planar_box.self.placement))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (((('AUTOMOTIVE_DESIGN.' + 'PLANAR_BOX') == TYPEOF(self.self.styled_item.self.item)) and (('AUTOMOTIVE_DESIGN.' + 'CURVE_STYLE') == TYPEOF(self.self.styled_item.self.styles[1].self.presentation_style_assignment.self.styles[1]))) or ((('AUTOMOTIVE_DESIGN.' + 'PLANE') == TYPEOF(self.self.styled_item.self.item)) and (('AUTOMOTIVE_DESIGN.' + 'FILL_AREA_STYLE') == TYPEOF(self.self.styled_item.self.styles[1].self.presentation_style_assignment.self.styles[1])))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((SIZEOF(self.self.styled_item.self.styles) == 1) and (SIZEOF(self.self.styled_item.self.styles[1].self.presentation_style_assignment.self.styles) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY circle # +#################### +class circle(conic): + '''Entity circle definition. + + :param radius + :type radius:positive_length_measure + ''' + def __init__( self , inherited0__name , inherited1__position , radius, ): + conic.__init__(self , inherited0__name , inherited1__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._radius = positive_length_measure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY classification_role # +#################### +class classification_role(BaseEntityClass): + '''Entity classification_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY line # +#################### +class line(curve): + '''Entity line definition. + + :param pnt + :type pnt:cartesian_point + + :param dir + :type dir:vector + ''' + def __init__( self , inherited0__name , pnt,dir, ): + curve.__init__(self , inherited0__name , ) + self.pnt = pnt + self.dir = dir + + @apply + def pnt(): + def fget( self ): + return self._pnt + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pnt is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._pnt = cartesian_point(value) + else: + self._pnt = value + return property(**locals()) + + @apply + def dir(): + def fget( self ): + return self._dir + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dir is mantatory and can not be set to None') + if not check_type(value,vector): + self._dir = vector(value) + else: + self._dir = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.dir.self.dim == self.pnt.self.dim) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY revolute_pair_value # +#################### +class revolute_pair_value(pair_value): + '''Entity revolute_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:revolute_pair + + :param actual_rotation + :type actual_rotation:plane_angle_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_rotation, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_rotation = actual_rotation + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,revolute_pair): + self._pair_value_applies_to_pair = revolute_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_rotation(): + def fget( self ): + return self._actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_rotation is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._actual_rotation = plane_angle_measure(value) + else: + self._actual_rotation = value + return property(**locals()) + +#################### + # ENTITY approximation_tolerance_deviation # +#################### +class approximation_tolerance_deviation(founded_item): + '''Entity approximation_tolerance_deviation definition. + + :param tessellation_type + :type tessellation_type:approximation_method + + :param tolerances + :type tolerances:SET(1,2,'tolerance_deviation_select', scope = schema_scope) + + :param definition_space + :type definition_space:product_or_presentation_space + ''' + def __init__( self , tessellation_type,tolerances,definition_space, ): + founded_item.__init__(self , ) + self.tessellation_type = tessellation_type + self.tolerances = tolerances + self.definition_space = definition_space + + @apply + def tessellation_type(): + def fget( self ): + return self._tessellation_type + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tessellation_type is mantatory and can not be set to None') + if not check_type(value,approximation_method): + self._tessellation_type = approximation_method(value) + else: + self._tessellation_type = value + return property(**locals()) + + @apply + def tolerances(): + def fget( self ): + return self._tolerances + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tolerances is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'tolerance_deviation_select', scope = schema_scope)): + self._tolerances = SET(value) + else: + self._tolerances = value + return property(**locals()) + + @apply + def definition_space(): + def fget( self ): + return self._definition_space + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definition_space is mantatory and can not be set to None') + if not check_type(value,product_or_presentation_space): + self._definition_space = product_or_presentation_space(value) + else: + self._definition_space = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((HIINDEX(self.self.tolerances) == 1) XOR (TYPEOF(self.self.tolerances[1]) != TYPEOF(self.self.tolerances[2]))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY general_property_association # +#################### +class general_property_association(BaseEntityClass): + '''Entity general_property_association definition. + + :param name + :type name:label + + :param description + :type description:text + + :param base_definition + :type base_definition:general_property + + :param derived_definition + :type derived_definition:derived_property_select + ''' + def __init__( self , name,description,base_definition,derived_definition, ): + self.name = name + self.description = description + self.base_definition = base_definition + self.derived_definition = derived_definition + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def base_definition(): + def fget( self ): + return self._base_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument base_definition is mantatory and can not be set to None') + if not check_type(value,general_property): + self._base_definition = general_property(value) + else: + self._base_definition = value + return property(**locals()) + + @apply + def derived_definition(): + def fget( self ): + return self._derived_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument derived_definition is mantatory and can not be set to None') + if not check_type(value,derived_property_select): + self._derived_definition = derived_property_select(value) + else: + self._derived_definition = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self.derived_definition,'AUTOMOTIVE_DESIGN.GENERAL_PROPERTY_ASSOCIATION.DERIVED_DEFINITION')) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.derived_definition.self.name == self.base_definition.self.name) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY screw_pair_range # +#################### +class screw_pair_range(simple_pair_range): + '''Entity screw_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:screw_pair + + :param lower_limit_actual_rotation + :type lower_limit_actual_rotation:rotational_range_measure + + :param upper_limit_actual_rotation + :type upper_limit_actual_rotation:rotational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,lower_limit_actual_rotation,upper_limit_actual_rotation, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.lower_limit_actual_rotation = lower_limit_actual_rotation + self.upper_limit_actual_rotation = upper_limit_actual_rotation + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,screw_pair): + self._simple_pair_range_applies_to_pair = screw_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def lower_limit_actual_rotation(): + def fget( self ): + return self._lower_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_actual_rotation = rotational_range_measure(value) + else: + self._lower_limit_actual_rotation = value + return property(**locals()) + + @apply + def upper_limit_actual_rotation(): + def fget( self ): + return self._upper_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_actual_rotation = rotational_range_measure(value) + else: + self._upper_limit_actual_rotation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_rotation)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_rotation))) XOR (self.lower_limit_actual_rotation < self.upper_limit_actual_rotation)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY event_occurrence_context_assignment # +#################### +class event_occurrence_context_assignment(BaseEntityClass): + '''Entity event_occurrence_context_assignment definition. + + :param assigned_event_occurrence_assignment + :type assigned_event_occurrence_assignment:event_occurrence_assignment + + :param role + :type role:event_occurrence_context_role + ''' + def __init__( self , assigned_event_occurrence_assignment,role, ): + self.assigned_event_occurrence_assignment = assigned_event_occurrence_assignment + self.role = role + + @apply + def assigned_event_occurrence_assignment(): + def fget( self ): + return self._assigned_event_occurrence_assignment + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_event_occurrence_assignment is mantatory and can not be set to None') + if not check_type(value,event_occurrence_assignment): + self._assigned_event_occurrence_assignment = event_occurrence_assignment(value) + else: + self._assigned_event_occurrence_assignment = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,event_occurrence_context_role): + self._role = event_occurrence_context_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY property_definition_representation # +#################### +class property_definition_representation(BaseEntityClass): + '''Entity property_definition_representation definition. + + :param definition + :type definition:represented_definition + + :param used_representation + :type used_representation:representation + + :param description + :type description:text + + :param name + :type name:label + ''' + def __init__( self , definition,used_representation, ): + self.definition = definition + self.used_representation = used_representation + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definition is mantatory and can not be set to None') + if not check_type(value,represented_definition): + self._definition = represented_definition(value) + else: + self._definition = value + return property(**locals()) + + @apply + def used_representation(): + def fget( self ): + return self._used_representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument used_representation is mantatory and can not be set to None') + if not check_type(value,representation): + self._used_representation = representation(value) + else: + self._used_representation = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY surface_style_segmentation_curve # +#################### +class surface_style_segmentation_curve(founded_item): + '''Entity surface_style_segmentation_curve definition. + + :param style_of_segmentation_curve + :type style_of_segmentation_curve:curve_or_render + ''' + def __init__( self , style_of_segmentation_curve, ): + founded_item.__init__(self , ) + self.style_of_segmentation_curve = style_of_segmentation_curve + + @apply + def style_of_segmentation_curve(): + def fget( self ): + return self._style_of_segmentation_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument style_of_segmentation_curve is mantatory and can not be set to None') + if not check_type(value,curve_or_render): + self._style_of_segmentation_curve = curve_or_render(value) + else: + self._style_of_segmentation_curve = value + return property(**locals()) + +#################### + # ENTITY view_volume # +#################### +class view_volume(founded_item): + '''Entity view_volume definition. + + :param projection_type + :type projection_type:central_or_parallel + + :param projection_point + :type projection_point:cartesian_point + + :param view_plane_distance + :type view_plane_distance:length_measure + + :param front_plane_distance + :type front_plane_distance:length_measure + + :param front_plane_clipping + :type front_plane_clipping:BOOLEAN + + :param back_plane_distance + :type back_plane_distance:length_measure + + :param back_plane_clipping + :type back_plane_clipping:BOOLEAN + + :param view_volume_sides_clipping + :type view_volume_sides_clipping:BOOLEAN + + :param view_window + :type view_window:planar_box + ''' + def __init__( self , projection_type,projection_point,view_plane_distance,front_plane_distance,front_plane_clipping,back_plane_distance,back_plane_clipping,view_volume_sides_clipping,view_window, ): + founded_item.__init__(self , ) + self.projection_type = projection_type + self.projection_point = projection_point + self.view_plane_distance = view_plane_distance + self.front_plane_distance = front_plane_distance + self.front_plane_clipping = front_plane_clipping + self.back_plane_distance = back_plane_distance + self.back_plane_clipping = back_plane_clipping + self.view_volume_sides_clipping = view_volume_sides_clipping + self.view_window = view_window + + @apply + def projection_type(): + def fget( self ): + return self._projection_type + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument projection_type is mantatory and can not be set to None') + if not check_type(value,central_or_parallel): + self._projection_type = central_or_parallel(value) + else: + self._projection_type = value + return property(**locals()) + + @apply + def projection_point(): + def fget( self ): + return self._projection_point + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument projection_point is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._projection_point = cartesian_point(value) + else: + self._projection_point = value + return property(**locals()) + + @apply + def view_plane_distance(): + def fget( self ): + return self._view_plane_distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument view_plane_distance is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._view_plane_distance = length_measure(value) + else: + self._view_plane_distance = value + return property(**locals()) + + @apply + def front_plane_distance(): + def fget( self ): + return self._front_plane_distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument front_plane_distance is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._front_plane_distance = length_measure(value) + else: + self._front_plane_distance = value + return property(**locals()) + + @apply + def front_plane_clipping(): + def fget( self ): + return self._front_plane_clipping + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument front_plane_clipping is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._front_plane_clipping = BOOLEAN(value) + else: + self._front_plane_clipping = value + return property(**locals()) + + @apply + def back_plane_distance(): + def fget( self ): + return self._back_plane_distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument back_plane_distance is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._back_plane_distance = length_measure(value) + else: + self._back_plane_distance = value + return property(**locals()) + + @apply + def back_plane_clipping(): + def fget( self ): + return self._back_plane_clipping + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument back_plane_clipping is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._back_plane_clipping = BOOLEAN(value) + else: + self._back_plane_clipping = value + return property(**locals()) + + @apply + def view_volume_sides_clipping(): + def fget( self ): + return self._view_volume_sides_clipping + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument view_volume_sides_clipping is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._view_volume_sides_clipping = BOOLEAN(value) + else: + self._view_volume_sides_clipping = value + return property(**locals()) + + @apply + def view_window(): + def fget( self ): + return self._view_window + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument view_window is mantatory and can not be set to None') + if not check_type(value,planar_box): + self._view_window = planar_box(value) + else: + self._view_window = value + return property(**locals()) + +#################### + # ENTITY curve_swept_solid_shape_representation # +#################### +class curve_swept_solid_shape_representation(shape_representation): + '''Entity curve_swept_solid_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY material_property_representation # +#################### +class material_property_representation(property_definition_representation): + '''Entity material_property_representation definition. + + :param dependent_environment + :type dependent_environment:data_environment + ''' + def __init__( self , inherited0__definition , inherited1__used_representation , dependent_environment, ): + property_definition_representation.__init__(self , inherited0__definition , inherited1__used_representation , ) + self.dependent_environment = dependent_environment + + @apply + def dependent_environment(): + def fget( self ): + return self._dependent_environment + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dependent_environment is mantatory and can not be set to None') + if not check_type(value,data_environment): + self._dependent_environment = data_environment(value) + else: + self._dependent_environment = value + return property(**locals()) + +#################### + # ENTITY geometrical_tolerance_callout # +#################### +class geometrical_tolerance_callout(draughting_callout): + '''Entity geometrical_tolerance_callout definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + +#################### + # ENTITY comparison_equal # +#################### +class comparison_equal(comparison_expression): + '''Entity comparison_equal definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + comparison_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY geometric_set # +#################### +class geometric_set(geometric_representation_item): + '''Entity geometric_set definition. + + :param elements + :type elements:SET(1,None,'geometric_set_select', scope = schema_scope) + ''' + def __init__( self , inherited0__name , elements, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.elements = elements + + @apply + def elements(): + def fget( self ): + return self._elements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument elements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'geometric_set_select', scope = schema_scope)): + self._elements = SET(value) + else: + self._elements = value + return property(**locals()) + +#################### + # ENTITY geometric_curve_set # +#################### +class geometric_curve_set(geometric_set): + '''Entity geometric_curve_set definition. + ''' + def __init__( self , inherited0__name , inherited1__elements , ): + geometric_set.__init__(self , inherited0__name , inherited1__elements , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY prismatic_pair # +#################### +class prismatic_pair(kinematic_pair): + '''Entity prismatic_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + +#################### + # ENTITY vee_profile # +#################### +class vee_profile(shape_aspect): + '''Entity vee_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + +#################### + # ENTITY minus_function # +#################### +class minus_function(unary_function_call): + '''Entity minus_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY personal_address # +#################### +class personal_address(address): + '''Entity personal_address definition. + + :param people + :type people:SET(1,None,'person', scope = schema_scope) + + :param description + :type description:text + ''' + def __init__( self , inherited0__internal_location , inherited1__street_number , inherited2__street , inherited3__postal_box , inherited4__town , inherited5__region , inherited6__postal_code , inherited7__country , inherited8__facsimile_number , inherited9__telephone_number , inherited10__electronic_mail_address , inherited11__telex_number , people,description, ): + address.__init__(self , inherited0__internal_location , inherited1__street_number , inherited2__street , inherited3__postal_box , inherited4__town , inherited5__region , inherited6__postal_code , inherited7__country , inherited8__facsimile_number , inherited9__telephone_number , inherited10__electronic_mail_address , inherited11__telex_number , ) + self.people = people + self.description = description + + @apply + def people(): + def fget( self ): + return self._people + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument people is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'person', scope = schema_scope)): + self._people = SET(value) + else: + self._people = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY document_relationship # +#################### +class document_relationship(BaseEntityClass): + '''Entity document_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_document + :type relating_document:document + + :param related_document + :type related_document:document + ''' + def __init__( self , name,description,relating_document,related_document, ): + self.name = name + self.description = description + self.relating_document = relating_document + self.related_document = related_document + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_document(): + def fget( self ): + return self._relating_document + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_document is mantatory and can not be set to None') + if not check_type(value,document): + self._relating_document = document(value) + else: + self._relating_document = value + return property(**locals()) + + @apply + def related_document(): + def fget( self ): + return self._related_document + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_document is mantatory and can not be set to None') + if not check_type(value,document): + self._related_document = document(value) + else: + self._related_document = value + return property(**locals()) + +#################### + # ENTITY make_from_usage_option # +#################### +class make_from_usage_option(product_definition_usage): + '''Entity make_from_usage_option definition. + + :param ranking + :type ranking:INTEGER + + :param ranking_rationale + :type ranking_rationale:text + + :param quantity + :type quantity:measure_with_unit + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , ranking,ranking_rationale,quantity, ): + product_definition_usage.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__relating_product_definition , inherited4__related_product_definition , ) + self.ranking = ranking + self.ranking_rationale = ranking_rationale + self.quantity = quantity + + @apply + def ranking(): + def fget( self ): + return self._ranking + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ranking is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._ranking = INTEGER(value) + else: + self._ranking = value + return property(**locals()) + + @apply + def ranking_rationale(): + def fget( self ): + return self._ranking_rationale + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ranking_rationale is mantatory and can not be set to None') + if not check_type(value,text): + self._ranking_rationale = text(value) + else: + self._ranking_rationale = value + return property(**locals()) + + @apply + def quantity(): + def fget( self ): + return self._quantity + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument quantity is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._quantity = measure_with_unit(value) + else: + self._quantity = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not ('NUMBER' == TYPEOF(self.quantity.self.value_component))) or (self.quantity.self.value_component > 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY outer_boundary_curve # +#################### +class outer_boundary_curve(boundary_curve): + '''Entity outer_boundary_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__segments , inherited2__self_intersect , ): + boundary_curve.__init__(self , inherited0__name , inherited1__segments , inherited2__self_intersect , ) + +#################### + # ENTITY shape_representation_relationship # +#################### +class shape_representation_relationship(representation_relationship): + '''Entity shape_representation_relationship definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , ): + representation_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION' == (TYPEOF(self.self.representation_relationship.self.rep_1) + TYPEOF(self.self.representation_relationship.self.rep_2))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY type_qualifier # +#################### +class type_qualifier(BaseEntityClass): + '''Entity type_qualifier definition. + + :param name + :type name:label + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY annotation_fill_area # +#################### +class annotation_fill_area(geometric_representation_item): + '''Entity annotation_fill_area definition. + + :param boundaries + :type boundaries:SET(1,None,'curve', scope = schema_scope) + ''' + def __init__( self , inherited0__name , boundaries, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.boundaries = boundaries + + @apply + def boundaries(): + def fget( self ): + return self._boundaries + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument boundaries is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'curve', scope = schema_scope)): + self._boundaries = SET(value) + else: + self._boundaries = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.self.geometric_representation_item.self.dim == 3) or (SIZEOF(None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_approval_assignment # +#################### +class applied_approval_assignment(approval_assignment): + '''Entity applied_approval_assignment definition. + + :param items + :type items:SET(1,None,'approval_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_approval , items, ): + approval_assignment.__init__(self , inherited0__assigned_approval , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'approval_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY assembly_component_usage_substitute # +#################### +class assembly_component_usage_substitute(BaseEntityClass): + '''Entity assembly_component_usage_substitute definition. + + :param name + :type name:label + + :param definition + :type definition:text + + :param base + :type base:assembly_component_usage + + :param substitute + :type substitute:assembly_component_usage + ''' + def __init__( self , name,definition,base,substitute, ): + self.name = name + self.definition = definition + self.base = base + self.substitute = substitute + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._definition = text(value) + else: + self._definition = value + else: + self._definition = value + return property(**locals()) + + @apply + def base(): + def fget( self ): + return self._base + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument base is mantatory and can not be set to None') + if not check_type(value,assembly_component_usage): + self._base = assembly_component_usage(value) + else: + self._base = value + return property(**locals()) + + @apply + def substitute(): + def fget( self ): + return self._substitute + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument substitute is mantatory and can not be set to None') + if not check_type(value,assembly_component_usage): + self._substitute = assembly_component_usage(value) + else: + self._substitute = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.base.self.relating_product_definition == self.substitute.self.relating_product_definition) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.base != self.substitute) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY drawing_definition # +#################### +class drawing_definition(BaseEntityClass): + '''Entity drawing_definition definition. + + :param drawing_number + :type drawing_number:identifier + + :param drawing_type + :type drawing_type:label + ''' + def __init__( self , drawing_number,drawing_type, ): + self.drawing_number = drawing_number + self.drawing_type = drawing_type + + @apply + def drawing_number(): + def fget( self ): + return self._drawing_number + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument drawing_number is mantatory and can not be set to None') + if not check_type(value,identifier): + self._drawing_number = identifier(value) + else: + self._drawing_number = value + return property(**locals()) + + @apply + def drawing_type(): + def fget( self ): + return self._drawing_type + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,label): + self._drawing_type = label(value) + else: + self._drawing_type = value + else: + self._drawing_type = value + return property(**locals()) + +#################### + # ENTITY degenerate_pcurve # +#################### +class degenerate_pcurve(point): + '''Entity degenerate_pcurve definition. + + :param basis_surface + :type basis_surface:surface + + :param reference_to_curve + :type reference_to_curve:definitional_representation + ''' + def __init__( self , inherited0__name , basis_surface,reference_to_curve, ): + point.__init__(self , inherited0__name , ) + self.basis_surface = basis_surface + self.reference_to_curve = reference_to_curve + + @apply + def basis_surface(): + def fget( self ): + return self._basis_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._basis_surface = surface(value) + else: + self._basis_surface = value + return property(**locals()) + + @apply + def reference_to_curve(): + def fget( self ): + return self._reference_to_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reference_to_curve is mantatory and can not be set to None') + if not check_type(value,definitional_representation): + self._reference_to_curve = definitional_representation(value) + else: + self._reference_to_curve = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.reference_to_curve.self.representation.self.items) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('AUTOMOTIVE_DESIGN.CURVE' == TYPEOF(self.reference_to_curve.self.representation.self.items[1])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.reference_to_curve.self.representation.self.items[1].self.geometric_representation_item.self.dim == 2) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY evaluated_degenerate_pcurve # +#################### +class evaluated_degenerate_pcurve(degenerate_pcurve): + '''Entity evaluated_degenerate_pcurve definition. + + :param equivalent_point + :type equivalent_point:cartesian_point + ''' + def __init__( self , inherited0__name , inherited1__basis_surface , inherited2__reference_to_curve , equivalent_point, ): + degenerate_pcurve.__init__(self , inherited0__name , inherited1__basis_surface , inherited2__reference_to_curve , ) + self.equivalent_point = equivalent_point + + @apply + def equivalent_point(): + def fget( self ): + return self._equivalent_point + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument equivalent_point is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._equivalent_point = cartesian_point(value) + else: + self._equivalent_point = value + return property(**locals()) + +#################### + # ENTITY open_path_profile # +#################### +class open_path_profile(shape_aspect): + '''Entity open_path_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) == SIZEOF(None))) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + +#################### + # ENTITY solid_angle_measure_with_unit # +#################### +class solid_angle_measure_with_unit(measure_with_unit): + '''Entity solid_angle_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.SOLID_ANGLE_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY resource_requirement_type # +#################### +class resource_requirement_type(BaseEntityClass): + '''Entity resource_requirement_type definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY replicate_feature # +#################### +class replicate_feature(feature_definition): + '''Entity replicate_feature definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY circular_pattern # +#################### +class circular_pattern(replicate_feature): + '''Entity circular_pattern definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + replicate_feature.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = ((SIZEOF(None) == 1) and (SIZEOF(None) == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) <= 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY connected_edge_set # +#################### +class connected_edge_set(topological_representation_item): + '''Entity connected_edge_set definition. + + :param ces_edges + :type ces_edges:SET(1,None,'edge', scope = schema_scope) + ''' + def __init__( self , inherited0__name , ces_edges, ): + topological_representation_item.__init__(self , inherited0__name , ) + self.ces_edges = ces_edges + + @apply + def ces_edges(): + def fget( self ): + return self._ces_edges + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ces_edges is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'edge', scope = schema_scope)): + self._ces_edges = SET(value) + else: + self._ces_edges = value + return property(**locals()) + +#################### + # ENTITY externally_defined_feature_definition # +#################### +class externally_defined_feature_definition(feature_definition,externally_defined_item): + '''Entity externally_defined_feature_definition definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__item_id , inherited3__source , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + externally_defined_item.__init__(self , inherited2__item_id , inherited3__source , ) + def wr1(self): + eval_wr1_wr = ((self.self.externally_defined_item.self.item_id == 'external thread') and (self.self.externally_defined_item.self.source.self.source_id == 'external feature specification')) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.APPLIED_CLASSIFICATION_ASSIGNMENT.ITEMS')) == 1) or ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.APPLIED_DOCUMENT_REFERENCE.ITEMS')) + SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.APPLIED_DOCUMENT_USAGE_CONSTRAINT_ASSIGNMENT.ITEMS'))) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 1) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) <= 1) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY homokinetic_pair # +#################### +class homokinetic_pair(universal_pair): + '''Entity homokinetic_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__input_skew_angle , ): + universal_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , inherited5__input_skew_angle , ) + def wr1(self): + eval_wr1_wr = ( not EXISTS(self.self.input_skew_angle)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY executed_action # +#################### +class executed_action(action): + '''Entity executed_action definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__chosen_method , ): + action.__init__(self , inherited0__name , inherited1__description , inherited2__chosen_method , ) + +#################### + # ENTITY directed_action # +#################### +class directed_action(executed_action): + '''Entity directed_action definition. + + :param directive + :type directive:action_directive + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__chosen_method , directive, ): + executed_action.__init__(self , inherited0__name , inherited1__description , inherited2__chosen_method , ) + self.directive = directive + + @apply + def directive(): + def fget( self ): + return self._directive + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directive is mantatory and can not be set to None') + if not check_type(value,action_directive): + self._directive = action_directive(value) + else: + self._directive = value + return property(**locals()) + +#################### + # ENTITY pre_defined_curve_font # +#################### +class pre_defined_curve_font(pre_defined_item): + '''Entity pre_defined_curve_font definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY draughting_pre_defined_curve_font # +#################### +class draughting_pre_defined_curve_font(pre_defined_curve_font): + '''Entity draughting_pre_defined_curve_font definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_curve_font.__init__(self , inherited0__name , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['continuous','chain','chain double dash','dashed','dotted']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY draughting_specification_reference # +#################### +class draughting_specification_reference(document_reference): + '''Entity draughting_specification_reference definition. + + :param specified_items + :type specified_items:SET(1,None,'specified_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_document , inherited1__source , specified_items, ): + document_reference.__init__(self , inherited0__assigned_document , inherited1__source , ) + self.specified_items = specified_items + + @apply + def specified_items(): + def fget( self ): + return self._specified_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument specified_items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'specified_item', scope = schema_scope)): + self._specified_items = SET(value) + else: + self._specified_items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.assigned_document.self.kind.self.product_data_type == 'draughting specification') + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY instanced_feature # +#################### +class instanced_feature(shape_aspect,feature_definition): + '''Entity instanced_feature definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , inherited4__name , inherited5__description , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + feature_definition.__init__(self , inherited4__name , inherited5__description , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'PRODUCT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = self.self.product_definitional + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY organizational_project # +#################### +class organizational_project(BaseEntityClass): + '''Entity organizational_project definition. + + :param name + :type name:label + + :param description + :type description:text + + :param responsible_organizations + :type responsible_organizations:SET(1,None,'organization', scope = schema_scope) + + :param id + :type id:identifier + ''' + def __init__( self , name,description,responsible_organizations, ): + self.name = name + self.description = description + self.responsible_organizations = responsible_organizations + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def responsible_organizations(): + def fget( self ): + return self._responsible_organizations + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument responsible_organizations is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'organization', scope = schema_scope)): + self._responsible_organizations = SET(value) + else: + self._responsible_organizations = value + return property(**locals()) + + @apply + def id(): + def fget( self ): + attribute_eval = get_id_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument id is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY date_time_role # +#################### +class date_time_role(BaseEntityClass): + '''Entity date_time_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ratio_unit # +#################### +class ratio_unit(named_unit): + '''Entity ratio_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 0) and (self.self.named_unit.self.dimensions.self.mass_exponent == 0)) and (self.self.named_unit.self.dimensions.self.time_exponent == 0)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 0)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 0)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 0)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY surface_style_reflectance_ambient_diffuse_specular # +#################### +class surface_style_reflectance_ambient_diffuse_specular(surface_style_reflectance_ambient_diffuse): + '''Entity surface_style_reflectance_ambient_diffuse_specular definition. + + :param specular_reflectance + :type specular_reflectance:REAL + + :param specular_exponent + :type specular_exponent:REAL + + :param specular_colour + :type specular_colour:colour + ''' + def __init__( self , inherited0__ambient_reflectance , inherited1__diffuse_reflectance , specular_reflectance,specular_exponent,specular_colour, ): + surface_style_reflectance_ambient_diffuse.__init__(self , inherited0__ambient_reflectance , inherited1__diffuse_reflectance , ) + self.specular_reflectance = specular_reflectance + self.specular_exponent = specular_exponent + self.specular_colour = specular_colour + + @apply + def specular_reflectance(): + def fget( self ): + return self._specular_reflectance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument specular_reflectance is mantatory and can not be set to None') + if not check_type(value,REAL): + self._specular_reflectance = REAL(value) + else: + self._specular_reflectance = value + return property(**locals()) + + @apply + def specular_exponent(): + def fget( self ): + return self._specular_exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument specular_exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._specular_exponent = REAL(value) + else: + self._specular_exponent = value + return property(**locals()) + + @apply + def specular_colour(): + def fget( self ): + return self._specular_colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument specular_colour is mantatory and can not be set to None') + if not check_type(value,colour): + self._specular_colour = colour(value) + else: + self._specular_colour = value + return property(**locals()) + +#################### + # ENTITY xor_expression # +#################### +class xor_expression(binary_boolean_expression): + '''Entity xor_expression definition. + + :param binary_generic_expression_operands + :type binary_generic_expression_operands:LIST(2,2,'boolean_expression', scope = schema_scope) + ''' + def __init__( self , inherited0__operands , binary_generic_expression_operands, ): + binary_boolean_expression.__init__(self , inherited0__operands , ) + self.binary_generic_expression_operands = binary_generic_expression_operands + + @apply + def binary_generic_expression_operands(): + def fget( self ): + return self._binary_generic_expression_operands + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument binary_generic_expression_operands is mantatory and can not be set to None') + if not check_type(value,LIST(2,2,'boolean_expression', scope = schema_scope)): + self._binary_generic_expression_operands = LIST(value) + else: + self._binary_generic_expression_operands = value + return property(**locals()) + +#################### + # ENTITY action_relationship # +#################### +class action_relationship(BaseEntityClass): + '''Entity action_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_action + :type relating_action:action + + :param related_action + :type related_action:action + ''' + def __init__( self , name,description,relating_action,related_action, ): + self.name = name + self.description = description + self.relating_action = relating_action + self.related_action = related_action + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_action(): + def fget( self ): + return self._relating_action + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_action is mantatory and can not be set to None') + if not check_type(value,action): + self._relating_action = action(value) + else: + self._relating_action = value + return property(**locals()) + + @apply + def related_action(): + def fget( self ): + return self._related_action + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_action is mantatory and can not be set to None') + if not check_type(value,action): + self._related_action = action(value) + else: + self._related_action = value + return property(**locals()) + +#################### + # ENTITY applied_document_reference # +#################### +class applied_document_reference(document_reference): + '''Entity applied_document_reference definition. + + :param items + :type items:SET(1,None,'document_reference_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_document , inherited1__source , items, ): + document_reference.__init__(self , inherited0__assigned_document , inherited1__source , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'document_reference_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (self.self.role.self.name == 'general tolerance definition')) or item_correlation(self.self.items,['REPRESENTATION'])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((self.self.role.self.name == 'general tolerance definition') or item_correlation(self.self.items,['ACTION','ACTION_DIRECTIVE','ACTION_METHOD','ACTION_RELATIONSHIP','APPLIED_ACTION_ASSIGNMENT','APPROVAL','CERTIFICATION','CLASS','CLASS_SYSTEM','CONFIGURATION_DESIGN','CONFIGURATION_ITEM','CONTRACT','FEATURE_DEFINITION','GENERAL_PROPERTY','MATERIAL_DESIGNATION','ORGANIZATION','ORGANIZATIONAL_PROJECT','PERSON','PRODUCT_CONCEPT','PRODUCT_CONCEPT_FEATURE','PRODUCT_CONCEPT_FEATURE_CATEGORY','PRODUCT_DEFINITION','PRODUCT_DEFINITION_FORMATION','PRODUCT_DEFINITION_FORMATION_RELATIONSHIP','PRODUCT_DEFINITION_RELATIONSHIP','PRODUCT_DEFINITION_SUBSTITUTE','PRODUCT_RELATED_PRODUCT_CATEGORY','PROPERTY_DEFINITION','REPRESENTATION','RESOURCE_REQUIREMENT_TYPE','SECURITY_CLASSIFICATION','SHAPE_ASPECT','SHAPE_ASPECT_RELATIONSHIP','VERSIONED_ACTION_REQUEST'])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY area_in_set # +#################### +class area_in_set(BaseEntityClass): + '''Entity area_in_set definition. + + :param area + :type area:presentation_area + + :param in_set + :type in_set:presentation_set + ''' + def __init__( self , area,in_set, ): + self.area = area + self.in_set = in_set + + @apply + def area(): + def fget( self ): + return self._area + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument area is mantatory and can not be set to None') + if not check_type(value,presentation_area): + self._area = presentation_area(value) + else: + self._area = value + return property(**locals()) + + @apply + def in_set(): + def fget( self ): + return self._in_set + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument in_set is mantatory and can not be set to None') + if not check_type(value,presentation_set): + self._in_set = presentation_set(value) + else: + self._in_set = value + return property(**locals()) + +#################### + # ENTITY extruded_area_solid # +#################### +class extruded_area_solid(swept_area_solid): + '''Entity extruded_area_solid definition. + + :param extruded_direction + :type extruded_direction:direction + + :param depth + :type depth:positive_length_measure + ''' + def __init__( self , inherited0__name , inherited1__swept_area , extruded_direction,depth, ): + swept_area_solid.__init__(self , inherited0__name , inherited1__swept_area , ) + self.extruded_direction = extruded_direction + self.depth = depth + + @apply + def extruded_direction(): + def fget( self ): + return self._extruded_direction + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extruded_direction is mantatory and can not be set to None') + if not check_type(value,direction): + self._extruded_direction = direction(value) + else: + self._extruded_direction = value + return property(**locals()) + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._depth = positive_length_measure(value) + else: + self._depth = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (dot_product(self.self.swept_area_solid.self.swept_area.self.basis_surface.self.elementary_surface.self.position.self.p[3],self.extruded_direction) != 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY kinematic_ground_representation # +#################### +class kinematic_ground_representation(representation): + '''Entity kinematic_ground_representation definition. + + :param property + :type property:kinematic_property_representation_relation + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + + @apply + def property(): + def fget( self ): + return self._property + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument property is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.GEOMETRIC_REPRESENTATION_CONTEXT' == TYPEOF(self.self.representation.self.context_of_items)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY kinematic_joint # +#################### +class kinematic_joint(BaseEntityClass): + '''Entity kinematic_joint definition. + + :param first_link + :type first_link:kinematic_link + + :param second_link + :type second_link:kinematic_link + + :param structure + :type structure:kinematic_structure + ''' + def __init__( self , first_link,second_link, ): + self.first_link = first_link + self.second_link = second_link + + @apply + def first_link(): + def fget( self ): + return self._first_link + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument first_link is mantatory and can not be set to None') + if not check_type(value,kinematic_link): + self._first_link = kinematic_link(value) + else: + self._first_link = value + return property(**locals()) + + @apply + def second_link(): + def fget( self ): + return self._second_link + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument second_link is mantatory and can not be set to None') + if not check_type(value,kinematic_link): + self._second_link = kinematic_link(value) + else: + self._second_link = value + return property(**locals()) + + @apply + def structure(): + def fget( self ): + return self._structure + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument structure is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.first_link != self.second_link) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY power_expression # +#################### +class power_expression(binary_numeric_expression): + '''Entity power_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + binary_numeric_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY external_source # +#################### +class external_source(BaseEntityClass): + '''Entity external_source definition. + + :param source_id + :type source_id:source_item + + :param description + :type description:text + ''' + def __init__( self , source_id, ): + self.source_id = source_id + + @apply + def source_id(): + def fget( self ): + return self._source_id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument source_id is mantatory and can not be set to None') + if not check_type(value,source_item): + self._source_id = source_item(value) + else: + self._source_id = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY known_source # +#################### +class known_source(external_source,pre_defined_item): + '''Entity known_source definition. + ''' + def __init__( self , inherited0__source_id , inherited1__name , ): + external_source.__init__(self , inherited0__source_id , ) + pre_defined_item.__init__(self , inherited1__name , ) + +#################### + # ENTITY extension # +#################### +class extension(derived_shape_aspect): + '''Entity extension definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + derived_shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.derived_shape_aspect.self.deriving_relationships) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY colour_specification # +#################### +class colour_specification(colour): + '''Entity colour_specification definition. + + :param name + :type name:label + ''' + def __init__( self , name, ): + colour.__init__(self , ) + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY curve_bounded_surface # +#################### +class curve_bounded_surface(bounded_surface): + '''Entity curve_bounded_surface definition. + + :param basis_surface + :type basis_surface:surface + + :param boundaries + :type boundaries:SET(1,None,'boundary_curve', scope = schema_scope) + + :param implicit_outer + :type implicit_outer:BOOLEAN + ''' + def __init__( self , inherited0__name , basis_surface,boundaries,implicit_outer, ): + bounded_surface.__init__(self , inherited0__name , ) + self.basis_surface = basis_surface + self.boundaries = boundaries + self.implicit_outer = implicit_outer + + @apply + def basis_surface(): + def fget( self ): + return self._basis_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._basis_surface = surface(value) + else: + self._basis_surface = value + return property(**locals()) + + @apply + def boundaries(): + def fget( self ): + return self._boundaries + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument boundaries is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'boundary_curve', scope = schema_scope)): + self._boundaries = SET(value) + else: + self._boundaries = value + return property(**locals()) + + @apply + def implicit_outer(): + def fget( self ): + return self._implicit_outer + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument implicit_outer is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._implicit_outer = BOOLEAN(value) + else: + self._implicit_outer = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not self.implicit_outer) or (SIZEOF(None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not self.implicit_outer) or ('AUTOMOTIVE_DESIGN.BOUNDED_SURFACE' == TYPEOF(self.basis_surface))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) <= 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY feature_pattern # +#################### +class feature_pattern(replicate_feature): + '''Entity feature_pattern definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + replicate_feature.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY leader_curve # +#################### +class leader_curve(annotation_curve_occurrence): + '''Entity leader_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , ): + annotation_curve_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) >= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY material_designation # +#################### +class material_designation(BaseEntityClass): + '''Entity material_designation definition. + + :param name + :type name:label + + :param definitions + :type definitions:SET(1,None,'characterized_definition', scope = schema_scope) + ''' + def __init__( self , name,definitions, ): + self.name = name + self.definitions = definitions + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def definitions(): + def fget( self ): + return self._definitions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definitions is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'characterized_definition', scope = schema_scope)): + self._definitions = SET(value) + else: + self._definitions = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY background_colour # +#################### +class background_colour(colour): + '''Entity background_colour definition. + + :param presentation + :type presentation:area_or_view + ''' + def __init__( self , presentation, ): + colour.__init__(self , ) + self.presentation = presentation + + @apply + def presentation(): + def fget( self ): + return self._presentation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument presentation is mantatory and can not be set to None') + if not check_type(value,area_or_view): + self._presentation = area_or_view(value) + else: + self._presentation = value + return property(**locals()) + +#################### + # ENTITY closed_shell # +#################### +class closed_shell(connected_face_set): + '''Entity closed_shell definition. + ''' + def __init__( self , inherited0__name , inherited1__cfs_faces , ): + connected_face_set.__init__(self , inherited0__name , inherited1__cfs_faces , ) + +#################### + # ENTITY comparison_less_equal # +#################### +class comparison_less_equal(comparison_expression): + '''Entity comparison_less_equal definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + comparison_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY round_hole # +#################### +class round_hole(feature_definition): + '''Entity round_hole definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) <= 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY externally_defined_general_property # +#################### +class externally_defined_general_property(general_property,externally_defined_item): + '''Entity externally_defined_general_property definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__item_id , inherited4__source , ): + general_property.__init__(self , inherited0__id , inherited1__name , inherited2__description , ) + externally_defined_item.__init__(self , inherited3__item_id , inherited4__source , ) + +#################### + # ENTITY name_assignment # +#################### +class name_assignment(BaseEntityClass): + '''Entity name_assignment definition. + + :param assigned_name + :type assigned_name:label + + :param role + :type role:object_role + ''' + def __init__( self , assigned_name, ): + self.assigned_name = assigned_name + + @apply + def assigned_name(): + def fget( self ): + return self._assigned_name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_name is mantatory and can not be set to None') + if not check_type(value,label): + self._assigned_name = label(value) + else: + self._assigned_name = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_name_assignment # +#################### +class applied_name_assignment(name_assignment): + '''Entity applied_name_assignment definition. + + :param items + :type items:SET(1,None,'name_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_name , items, ): + name_assignment.__init__(self , inherited0__assigned_name , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'name_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (self.self.role.self.name == 'kinematic element name')) or item_correlation(self.self.items,['KINEMATIC_STRUCTURE','KINEMATIC_JOINT','KINEMATIC_LINK'])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY draughting_subfigure_representation # +#################### +class draughting_subfigure_representation(symbol_representation): + '''Entity draughting_subfigure_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + symbol_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) >= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) > 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ( not acyclic_mapped_item_usage(self)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(self.self.context_of_items.self.representations_in_context) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY draughting_text_literal_with_delineation # +#################### +class draughting_text_literal_with_delineation(text_literal_with_delineation): + '''Entity draughting_text_literal_with_delineation definition. + ''' + def __init__( self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , inherited6__delineation , ): + text_literal_with_delineation.__init__(self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , inherited6__delineation , ) + def wr1(self): + eval_wr1_wr = (self.self.delineation == ['underline','overline']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY qualified_representation_item # +#################### +class qualified_representation_item(representation_item): + '''Entity qualified_representation_item definition. + + :param qualifiers + :type qualifiers:SET(1,None,'value_qualifier', scope = schema_scope) + ''' + def __init__( self , inherited0__name , qualifiers, ): + representation_item.__init__(self , inherited0__name , ) + self.qualifiers = qualifiers + + @apply + def qualifiers(): + def fget( self ): + return self._qualifiers + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument qualifiers is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'value_qualifier', scope = schema_scope)): + self._qualifiers = SET(value) + else: + self._qualifiers = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) < 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY time_interval_role # +#################### +class time_interval_role(BaseEntityClass): + '''Entity time_interval_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY effectivity_context_assignment # +#################### +class effectivity_context_assignment(BaseEntityClass): + '''Entity effectivity_context_assignment definition. + + :param assigned_effectivity_assignment + :type assigned_effectivity_assignment:effectivity_assignment + + :param role + :type role:effectivity_context_role + ''' + def __init__( self , assigned_effectivity_assignment,role, ): + self.assigned_effectivity_assignment = assigned_effectivity_assignment + self.role = role + + @apply + def assigned_effectivity_assignment(): + def fget( self ): + return self._assigned_effectivity_assignment + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_effectivity_assignment is mantatory and can not be set to None') + if not check_type(value,effectivity_assignment): + self._assigned_effectivity_assignment = effectivity_assignment(value) + else: + self._assigned_effectivity_assignment = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,effectivity_context_role): + self._role = effectivity_context_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY configured_effectivity_context_assignment # +#################### +class configured_effectivity_context_assignment(effectivity_context_assignment): + '''Entity configured_effectivity_context_assignment definition. + + :param items + :type items:SET(1,None,'configured_effectivity_context_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_effectivity_assignment , inherited1__role , items, ): + effectivity_context_assignment.__init__(self , inherited0__assigned_effectivity_assignment , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'configured_effectivity_context_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'CONFIGURED_EFFECTIVITY_ASSIGNMENT') == TYPEOF(self.self.assigned_effectivity_assignment)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(self.self.items) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY drawing_revision # +#################### +class drawing_revision(presentation_set): + '''Entity drawing_revision definition. + + :param revision_identifier + :type revision_identifier:identifier + + :param drawing_identifier + :type drawing_identifier:drawing_definition + + :param intended_scale + :type intended_scale:text + ''' + def __init__( self , revision_identifier,drawing_identifier,intended_scale, ): + presentation_set.__init__(self , ) + self.revision_identifier = revision_identifier + self.drawing_identifier = drawing_identifier + self.intended_scale = intended_scale + + @apply + def revision_identifier(): + def fget( self ): + return self._revision_identifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument revision_identifier is mantatory and can not be set to None') + if not check_type(value,identifier): + self._revision_identifier = identifier(value) + else: + self._revision_identifier = value + return property(**locals()) + + @apply + def drawing_identifier(): + def fget( self ): + return self._drawing_identifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument drawing_identifier is mantatory and can not be set to None') + if not check_type(value,drawing_definition): + self._drawing_identifier = drawing_definition(value) + else: + self._drawing_identifier = value + return property(**locals()) + + @apply + def intended_scale(): + def fget( self ): + return self._intended_scale + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._intended_scale = text(value) + else: + self._intended_scale = value + else: + self._intended_scale = value + return property(**locals()) + +#################### + # ENTITY non_manifold_surface_shape_representation # +#################### +class non_manifold_surface_shape_representation(shape_representation): + '''Entity non_manifold_surface_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 0) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 0) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) == 0) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(None) == 0) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = (SIZEOF(None) == 0) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + def wr14(self): + eval_wr14_wr = (SIZEOF(None) == 0) + if not eval_wr14_wr: + raise AssertionError('Rule wr14 violated') + else: + return eval_wr14_wr + + +#################### + # ENTITY angularity_tolerance # +#################### +class angularity_tolerance(geometric_tolerance_with_datum_reference): + '''Entity angularity_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ): + geometric_tolerance_with_datum_reference.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) < 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY mod_expression # +#################### +class mod_expression(binary_numeric_expression): + '''Entity mod_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + binary_numeric_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY placed_datum_target_feature # +#################### +class placed_datum_target_feature(datum_target): + '''Entity placed_datum_target_feature definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , inherited4__target_id , ): + datum_target.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , inherited4__target_id , ) + def wr1(self): + eval_wr1_wr = (self.self.description == ['point','line','rectangle','circle']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.description != 'point') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'circle') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'rectangle') or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((self.self.description != 'circle') or (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((self.self.description != 'line') or (SIZEOF(None) == 1)) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = ((self.self.description != 'rectangle') or (SIZEOF(None) == 1)) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = ((self.self.description != 'rectangle') or (SIZEOF(None) == 1)) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + +#################### + # ENTITY product_concept_feature_category_usage # +#################### +class product_concept_feature_category_usage(group_assignment): + '''Entity product_concept_feature_category_usage definition. + + :param items + :type items:SET(1,None,'category_usage_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_group , items, ): + group_assignment.__init__(self , inherited0__assigned_group , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'category_usage_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'PRODUCT_CONCEPT_FEATURE_CATEGORY') == TYPEOF(self.self.assigned_group)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.role.self.name == ['mandatory category usage','optional category usage']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY box_domain # +#################### +class box_domain(founded_item): + '''Entity box_domain definition. + + :param corner + :type corner:cartesian_point + + :param xlength + :type xlength:positive_length_measure + + :param ylength + :type ylength:positive_length_measure + + :param zlength + :type zlength:positive_length_measure + ''' + def __init__( self , corner,xlength,ylength,zlength, ): + founded_item.__init__(self , ) + self.corner = corner + self.xlength = xlength + self.ylength = ylength + self.zlength = zlength + + @apply + def corner(): + def fget( self ): + return self._corner + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument corner is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._corner = cartesian_point(value) + else: + self._corner = value + return property(**locals()) + + @apply + def xlength(): + def fget( self ): + return self._xlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument xlength is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._xlength = positive_length_measure(value) + else: + self._xlength = value + return property(**locals()) + + @apply + def ylength(): + def fget( self ): + return self._ylength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ylength is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._ylength = positive_length_measure(value) + else: + self._ylength = value + return property(**locals()) + + @apply + def zlength(): + def fget( self ): + return self._zlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument zlength is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._zlength = positive_length_measure(value) + else: + self._zlength = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY definitional_representation # +#################### +class definitional_representation(representation): + '''Entity definitional_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.PARAMETRIC_REPRESENTATION_CONTEXT' == TYPEOF(self.self.representation.self.context_of_items)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY precision_qualifier # +#################### +class precision_qualifier(BaseEntityClass): + '''Entity precision_qualifier definition. + + :param precision_value + :type precision_value:INTEGER + ''' + def __init__( self , precision_value, ): + self.precision_value = precision_value + + @apply + def precision_value(): + def fget( self ): + return self._precision_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument precision_value is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._precision_value = INTEGER(value) + else: + self._precision_value = value + return property(**locals()) + +#################### + # ENTITY action_method_relationship # +#################### +class action_method_relationship(BaseEntityClass): + '''Entity action_method_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_method + :type relating_method:action_method + + :param related_method + :type related_method:action_method + ''' + def __init__( self , name,description,relating_method,related_method, ): + self.name = name + self.description = description + self.relating_method = relating_method + self.related_method = related_method + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_method(): + def fget( self ): + return self._relating_method + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_method is mantatory and can not be set to None') + if not check_type(value,action_method): + self._relating_method = action_method(value) + else: + self._relating_method = value + return property(**locals()) + + @apply + def related_method(): + def fget( self ): + return self._related_method + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_method is mantatory and can not be set to None') + if not check_type(value,action_method): + self._related_method = action_method(value) + else: + self._related_method = value + return property(**locals()) + +#################### + # ENTITY date_role # +#################### +class date_role(BaseEntityClass): + '''Entity date_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY int_numeric_variable # +#################### +class int_numeric_variable(numeric_variable): + '''Entity int_numeric_variable definition. + ''' + def __init__( self , ): + numeric_variable.__init__(self , ) + +#################### + # ENTITY dimension_callout_component_relationship # +#################### +class dimension_callout_component_relationship(draughting_callout_relationship): + '''Entity dimension_callout_component_relationship definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_draughting_callout , inherited3__related_draughting_callout , ): + draughting_callout_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_draughting_callout , inherited3__related_draughting_callout , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['prefix','suffix']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('AUTOMOTIVE_DESIGN.STRUCTURED_DIMENSION_CALLOUT' == TYPEOF(self.self.relating_draughting_callout)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(TYPEOF(self.self.related_draughting_callout) * ['AUTOMOTIVE_DESIGN.LEADER_DIRECTED_CALLOUT','AUTOMOTIVE_DESIGN.PROJECTION_DIRECTED_CALLOUT','AUTOMOTIVE_DESIGN.DIMENSION_CURVE_DIRECTED_CALLOUT','AUTOMOTIVE_DESIGN.STRUCTURED_DIMENSION_CALLOUT']) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.related_draughting_callout.self.contents * self.self.relating_draughting_callout.self.contents) == self.self.related_draughting_callout.self.contents) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.name == 'prefix') and (SIZEOF(None) == 0)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.name == 'suffix') and (SIZEOF(None) == 0)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + +#################### + # ENTITY light_source_directional # +#################### +class light_source_directional(light_source): + '''Entity light_source_directional definition. + + :param orientation + :type orientation:direction + ''' + def __init__( self , inherited0__name , inherited1__light_colour , orientation, ): + light_source.__init__(self , inherited0__name , inherited1__light_colour , ) + self.orientation = orientation + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,direction): + self._orientation = direction(value) + else: + self._orientation = value + return property(**locals()) + +#################### + # ENTITY si_unit # +#################### +class si_unit(named_unit): + '''Entity si_unit definition. + + :param prefix + :type prefix:si_prefix + + :param name + :type name:si_unit_name + + :param named_unit_dimensions + :type named_unit_dimensions:dimensional_exponents + ''' + def __init__( self , inherited0__dimensions , prefix,name, ): + named_unit.__init__(self , inherited0__dimensions , ) + self.prefix = prefix + self.name = name + + @apply + def prefix(): + def fget( self ): + return self._prefix + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,si_prefix): + self._prefix = si_prefix(value) + else: + self._prefix = value + else: + self._prefix = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,si_unit_name): + self._name = si_unit_name(value) + else: + self._name = value + return property(**locals()) + + @apply + def named_unit_dimensions(): + def fget( self ): + attribute_eval = dimensions_for_si_unit(self.name) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument named_unit_dimensions is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (('AUTOMOTIVE_DESIGN.MASS_UNIT' == TYPEOF(self)) and (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DERIVED_UNIT_ELEMENT.UNIT')) > 0))) or (self.prefix == si_prefix.self.kilo)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY attribute_value_role # +#################### +class attribute_value_role(BaseEntityClass): + '''Entity attribute_value_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY document_usage_constraint_assignment # +#################### +class document_usage_constraint_assignment(BaseEntityClass): + '''Entity document_usage_constraint_assignment definition. + + :param assigned_document_usage + :type assigned_document_usage:document_usage_constraint + + :param role + :type role:document_usage_role + ''' + def __init__( self , assigned_document_usage,role, ): + self.assigned_document_usage = assigned_document_usage + self.role = role + + @apply + def assigned_document_usage(): + def fget( self ): + return self._assigned_document_usage + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_document_usage is mantatory and can not be set to None') + if not check_type(value,document_usage_constraint): + self._assigned_document_usage = document_usage_constraint(value) + else: + self._assigned_document_usage = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,document_usage_role): + self._role = document_usage_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY bezier_surface # +#################### +class bezier_surface(b_spline_surface): + '''Entity bezier_surface definition. + ''' + def __init__( self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , ): + b_spline_surface.__init__(self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , ) + +#################### + # ENTITY csg_solid # +#################### +class csg_solid(solid_model): + '''Entity csg_solid definition. + + :param tree_root_expression + :type tree_root_expression:csg_select + ''' + def __init__( self , inherited0__name , tree_root_expression, ): + solid_model.__init__(self , inherited0__name , ) + self.tree_root_expression = tree_root_expression + + @apply + def tree_root_expression(): + def fget( self ): + return self._tree_root_expression + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tree_root_expression is mantatory and can not be set to None') + if not check_type(value,csg_select): + self._tree_root_expression = csg_select(value) + else: + self._tree_root_expression = value + return property(**locals()) + +#################### + # ENTITY parallel_offset # +#################### +class parallel_offset(derived_shape_aspect): + '''Entity parallel_offset definition. + + :param offset + :type offset:measure_with_unit + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , offset, ): + derived_shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + self.offset = offset + + @apply + def offset(): + def fget( self ): + return self._offset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument offset is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._offset = measure_with_unit(value) + else: + self._offset = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.derived_shape_aspect.self.deriving_relationships) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY camera_model_d3_with_hlhsr # +#################### +class camera_model_d3_with_hlhsr(camera_model_d3): + '''Entity camera_model_d3_with_hlhsr definition. + + :param hidden_line_surface_removal + :type hidden_line_surface_removal:BOOLEAN + ''' + def __init__( self , inherited0__name , inherited1__view_reference_system , inherited2__perspective_of_volume , hidden_line_surface_removal, ): + camera_model_d3.__init__(self , inherited0__name , inherited1__view_reference_system , inherited2__perspective_of_volume , ) + self.hidden_line_surface_removal = hidden_line_surface_removal + + @apply + def hidden_line_surface_removal(): + def fget( self ): + return self._hidden_line_surface_removal + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hidden_line_surface_removal is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._hidden_line_surface_removal = BOOLEAN(value) + else: + self._hidden_line_surface_removal = value + return property(**locals()) + +#################### + # ENTITY person_and_organization_address # +#################### +class person_and_organization_address(organizational_address,personal_address): + '''Entity person_and_organization_address definition. + ''' + def __init__( self , inherited0__internal_location , inherited1__street_number , inherited2__street , inherited3__postal_box , inherited4__town , inherited5__region , inherited6__postal_code , inherited7__country , inherited8__facsimile_number , inherited9__telephone_number , inherited10__electronic_mail_address , inherited11__telex_number , inherited12__organizations , inherited13__description , inherited14__internal_location , inherited15__street_number , inherited16__street , inherited17__postal_box , inherited18__town , inherited19__region , inherited20__postal_code , inherited21__country , inherited22__facsimile_number , inherited23__telephone_number , inherited24__electronic_mail_address , inherited25__telex_number , inherited26__people , inherited27__description , ): + organizational_address.__init__(self , inherited0__internal_location , inherited1__street_number , inherited2__street , inherited3__postal_box , inherited4__town , inherited5__region , inherited6__postal_code , inherited7__country , inherited8__facsimile_number , inherited9__telephone_number , inherited10__electronic_mail_address , inherited11__telex_number , inherited12__organizations , inherited13__description , ) + personal_address.__init__(self , inherited14__internal_location , inherited15__street_number , inherited16__street , inherited17__postal_box , inherited18__town , inherited19__region , inherited20__postal_code , inherited21__country , inherited22__facsimile_number , inherited23__telephone_number , inherited24__electronic_mail_address , inherited25__telex_number , inherited26__people , inherited27__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.personal_address.self.people) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(self.self.organizational_address.self.organizations) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY fill_area_style_colour # +#################### +class fill_area_style_colour(BaseEntityClass): + '''Entity fill_area_style_colour definition. + + :param name + :type name:label + + :param fill_colour + :type fill_colour:colour + ''' + def __init__( self , name,fill_colour, ): + self.name = name + self.fill_colour = fill_colour + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def fill_colour(): + def fget( self ): + return self._fill_colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fill_colour is mantatory and can not be set to None') + if not check_type(value,colour): + self._fill_colour = colour(value) + else: + self._fill_colour = value + return property(**locals()) + +#################### + # ENTITY product_definition_with_associated_documents # +#################### +class product_definition_with_associated_documents(product_definition): + '''Entity product_definition_with_associated_documents definition. + + :param documentation_ids + :type documentation_ids:SET(1,None,'document', scope = schema_scope) + ''' + def __init__( self , inherited0__id , inherited1__description , inherited2__formation , inherited3__frame_of_reference , documentation_ids, ): + product_definition.__init__(self , inherited0__id , inherited1__description , inherited2__formation , inherited3__frame_of_reference , ) + self.documentation_ids = documentation_ids + + @apply + def documentation_ids(): + def fget( self ): + return self._documentation_ids + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument documentation_ids is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'document', scope = schema_scope)): + self._documentation_ids = SET(value) + else: + self._documentation_ids = value + return property(**locals()) + +#################### + # ENTITY physically_modelled_product_definition # +#################### +class physically_modelled_product_definition(product_definition_with_associated_documents): + '''Entity physically_modelled_product_definition definition. + ''' + def __init__( self , inherited0__id , inherited1__description , inherited2__formation , inherited3__frame_of_reference , inherited4__documentation_ids , ): + product_definition_with_associated_documents.__init__(self , inherited0__id , inherited1__description , inherited2__formation , inherited3__frame_of_reference , inherited4__documentation_ids , ) + def wr1(self): + eval_wr1_wr = (self.self.frame_of_reference.self.application_context_element.self.name == 'physical model occurrence') + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(self.documentation_ids) == 1) and (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY slash_expression # +#################### +class slash_expression(binary_numeric_expression): + '''Entity slash_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + binary_numeric_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY spherical_pair # +#################### +class spherical_pair(kinematic_pair): + '''Entity spherical_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + +#################### + # ENTITY surface_profile_tolerance # +#################### +class surface_profile_tolerance(geometric_tolerance): + '''Entity surface_profile_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + def wr1(self): + eval_wr1_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE') == TYPEOF(self))) or (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) <= 3)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY not_expression # +#################### +class not_expression(unary_boolean_expression): + '''Entity not_expression definition. + + :param unary_generic_expression_operand + :type unary_generic_expression_operand:boolean_expression + ''' + def __init__( self , inherited0__operand , unary_generic_expression_operand, ): + unary_boolean_expression.__init__(self , inherited0__operand , ) + self.unary_generic_expression_operand = unary_generic_expression_operand + + @apply + def unary_generic_expression_operand(): + def fget( self ): + return self._unary_generic_expression_operand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unary_generic_expression_operand is mantatory and can not be set to None') + if not check_type(value,boolean_expression): + self._unary_generic_expression_operand = boolean_expression(value) + else: + self._unary_generic_expression_operand = value + return property(**locals()) + +#################### + # ENTITY contract_type # +#################### +class contract_type(BaseEntityClass): + '''Entity contract_type definition. + + :param description + :type description:label + ''' + def __init__( self , description, ): + self.description = description + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,label): + self._description = label(value) + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY planar_shape_representation # +#################### +class planar_shape_representation(shape_representation): + '''Entity planar_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.items) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.self.name == ['profile limit','maximum feature limit']) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.name != 'maximum feature limit') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.name != 'profile limit') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY surface_pair_range # +#################### +class surface_pair_range(simple_pair_range): + '''Entity surface_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:surface_pair + + :param range_on_surface_1 + :type range_on_surface_1:rectangular_trimmed_surface + + :param range_on_surface_2 + :type range_on_surface_2:rectangular_trimmed_surface + + :param lower_limit_actual_rotation + :type lower_limit_actual_rotation:rotational_range_measure + + :param upper_limit_actual_rotation + :type upper_limit_actual_rotation:rotational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,range_on_surface_1,range_on_surface_2,lower_limit_actual_rotation,upper_limit_actual_rotation, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.range_on_surface_1 = range_on_surface_1 + self.range_on_surface_2 = range_on_surface_2 + self.lower_limit_actual_rotation = lower_limit_actual_rotation + self.upper_limit_actual_rotation = upper_limit_actual_rotation + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,surface_pair): + self._simple_pair_range_applies_to_pair = surface_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def range_on_surface_1(): + def fget( self ): + return self._range_on_surface_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument range_on_surface_1 is mantatory and can not be set to None') + if not check_type(value,rectangular_trimmed_surface): + self._range_on_surface_1 = rectangular_trimmed_surface(value) + else: + self._range_on_surface_1 = value + return property(**locals()) + + @apply + def range_on_surface_2(): + def fget( self ): + return self._range_on_surface_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument range_on_surface_2 is mantatory and can not be set to None') + if not check_type(value,rectangular_trimmed_surface): + self._range_on_surface_2 = rectangular_trimmed_surface(value) + else: + self._range_on_surface_2 = value + return property(**locals()) + + @apply + def lower_limit_actual_rotation(): + def fget( self ): + return self._lower_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_actual_rotation = rotational_range_measure(value) + else: + self._lower_limit_actual_rotation = value + return property(**locals()) + + @apply + def upper_limit_actual_rotation(): + def fget( self ): + return self._upper_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_actual_rotation = rotational_range_measure(value) + else: + self._upper_limit_actual_rotation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.simple_pair_range.self.applies_to_pair.self.surface_pair.self.surface_1 == self.range_on_surface_1.self.basis_surface) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.simple_pair_range.self.applies_to_pair.self.surface_pair.self.surface_2 == self.range_on_surface_2.self.basis_surface) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_rotation)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_rotation))) XOR (self.lower_limit_actual_rotation < self.upper_limit_actual_rotation)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY b_spline_curve_with_knots # +#################### +class b_spline_curve_with_knots(b_spline_curve): + '''Entity b_spline_curve_with_knots definition. + + :param knot_multiplicities + :type knot_multiplicities:LIST(2,None,'INTEGER', scope = schema_scope) + + :param knots + :type knots:LIST(2,None,'REAL', scope = schema_scope) + + :param knot_spec + :type knot_spec:knot_type + + :param upper_index_on_knots + :type upper_index_on_knots:INTEGER + ''' + def __init__( self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , knot_multiplicities,knots,knot_spec, ): + b_spline_curve.__init__(self , inherited0__name , inherited1__degree , inherited2__control_points_list , inherited3__curve_form , inherited4__closed_curve , inherited5__self_intersect , ) + self.knot_multiplicities = knot_multiplicities + self.knots = knots + self.knot_spec = knot_spec + + @apply + def knot_multiplicities(): + def fget( self ): + return self._knot_multiplicities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument knot_multiplicities is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'INTEGER', scope = schema_scope)): + self._knot_multiplicities = LIST(value) + else: + self._knot_multiplicities = value + return property(**locals()) + + @apply + def knots(): + def fget( self ): + return self._knots + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument knots is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._knots = LIST(value) + else: + self._knots = value + return property(**locals()) + + @apply + def knot_spec(): + def fget( self ): + return self._knot_spec + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument knot_spec is mantatory and can not be set to None') + if not check_type(value,knot_type): + self._knot_spec = knot_type(value) + else: + self._knot_spec = value + return property(**locals()) + + @apply + def upper_index_on_knots(): + def fget( self ): + attribute_eval = SIZEOF(self.knots) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument upper_index_on_knots is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = constraints_param_b_spline(self.degree,self.upper_index_on_knots,self.upper_index_on_control_points,self.knot_multiplicities,self.knots) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(self.knot_multiplicities) == self.upper_index_on_knots) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY document_usage_role # +#################### +class document_usage_role(BaseEntityClass): + '''Entity document_usage_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY fill_area_style_hatching # +#################### +class fill_area_style_hatching(geometric_representation_item): + '''Entity fill_area_style_hatching definition. + + :param hatch_line_appearance + :type hatch_line_appearance:curve_style + + :param start_of_next_hatch_line + :type start_of_next_hatch_line:one_direction_repeat_factor + + :param point_of_reference_hatch_line + :type point_of_reference_hatch_line:cartesian_point + + :param pattern_start + :type pattern_start:cartesian_point + + :param hatch_line_angle + :type hatch_line_angle:plane_angle_measure + ''' + def __init__( self , inherited0__name , hatch_line_appearance,start_of_next_hatch_line,point_of_reference_hatch_line,pattern_start,hatch_line_angle, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.hatch_line_appearance = hatch_line_appearance + self.start_of_next_hatch_line = start_of_next_hatch_line + self.point_of_reference_hatch_line = point_of_reference_hatch_line + self.pattern_start = pattern_start + self.hatch_line_angle = hatch_line_angle + + @apply + def hatch_line_appearance(): + def fget( self ): + return self._hatch_line_appearance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hatch_line_appearance is mantatory and can not be set to None') + if not check_type(value,curve_style): + self._hatch_line_appearance = curve_style(value) + else: + self._hatch_line_appearance = value + return property(**locals()) + + @apply + def start_of_next_hatch_line(): + def fget( self ): + return self._start_of_next_hatch_line + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument start_of_next_hatch_line is mantatory and can not be set to None') + if not check_type(value,one_direction_repeat_factor): + self._start_of_next_hatch_line = one_direction_repeat_factor(value) + else: + self._start_of_next_hatch_line = value + return property(**locals()) + + @apply + def point_of_reference_hatch_line(): + def fget( self ): + return self._point_of_reference_hatch_line + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument point_of_reference_hatch_line is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._point_of_reference_hatch_line = cartesian_point(value) + else: + self._point_of_reference_hatch_line = value + return property(**locals()) + + @apply + def pattern_start(): + def fget( self ): + return self._pattern_start + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pattern_start is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._pattern_start = cartesian_point(value) + else: + self._pattern_start = value + return property(**locals()) + + @apply + def hatch_line_angle(): + def fget( self ): + return self._hatch_line_angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hatch_line_angle is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._hatch_line_angle = plane_angle_measure(value) + else: + self._hatch_line_angle = value + return property(**locals()) + +#################### + # ENTITY initial_state # +#################### +class initial_state(BaseEntityClass): + '''Entity initial_state definition. + + :param applies_to_mechanism + :type applies_to_mechanism:mechanism + + :param pair_values + :type pair_values:SET(1,None,'pair_value', scope = schema_scope) + ''' + def __init__( self , applies_to_mechanism,pair_values, ): + self.applies_to_mechanism = applies_to_mechanism + self.pair_values = pair_values + + @apply + def applies_to_mechanism(): + def fget( self ): + return self._applies_to_mechanism + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applies_to_mechanism is mantatory and can not be set to None') + if not check_type(value,mechanism): + self._applies_to_mechanism = mechanism(value) + else: + self._applies_to_mechanism = value + return property(**locals()) + + @apply + def pair_values(): + def fget( self ): + return self._pair_values + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_values is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'pair_value', scope = schema_scope)): + self._pair_values = SET(value) + else: + self._pair_values = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY tangent # +#################### +class tangent(derived_shape_aspect): + '''Entity tangent definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + derived_shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.derived_shape_aspect.self.deriving_relationships) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ruled_surface_swept_area_solid # +#################### +class ruled_surface_swept_area_solid(surface_curve_swept_area_solid): + '''Entity ruled_surface_swept_area_solid definition. + ''' + def __init__( self , inherited0__name , inherited1__swept_area , inherited2__directrix , inherited3__start_param , inherited4__end_param , inherited5__reference_surface , ): + surface_curve_swept_area_solid.__init__(self , inherited0__name , inherited1__swept_area , inherited2__directrix , inherited3__start_param , inherited4__end_param , inherited5__reference_surface , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.B_SPLINE_SURFACE' == TYPEOF(self.self.reference_surface)) and (self.self.reference_surface.self.b_spline_surface.self.u_degree == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(self.self.directrix)) or (('AUTOMOTIVE_DESIGN.B_SPLINE_CURVE' == TYPEOF(self.self.directrix.self.surface_curve.self.curve_3d)) and (self.self.directrix.self.surface_curve.self.curve_3d.self.b_spline_curve.self.degree == self.self.reference_surface.self.b_spline_surface.self.v_degree))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY spherical_pair_value # +#################### +class spherical_pair_value(pair_value): + '''Entity spherical_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:spherical_pair + + :param input_orientation + :type input_orientation:spatial_rotation + + :param actual_orientation + :type actual_orientation:ARRAY(ypr_index(yaw),ypr_index(roll),'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,input_orientation, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.input_orientation = input_orientation + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,spherical_pair): + self._pair_value_applies_to_pair = spherical_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def input_orientation(): + def fget( self ): + return self._input_orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument input_orientation is mantatory and can not be set to None') + if not check_type(value,spatial_rotation): + self._input_orientation = spatial_rotation(value) + else: + self._input_orientation = value + return property(**locals()) + + @apply + def actual_orientation(): + def fget( self ): + attribute_eval = convert_spatial_to_ypr_rotation(self.self.pair_value.self.applies_to_pair,self.input_orientation) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument actual_orientation is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY attribute_language_assignment # +#################### +class attribute_language_assignment(attribute_classification_assignment): + '''Entity attribute_language_assignment definition. + + :param items + :type items:SET(1,None,'attribute_language_item', scope = schema_scope) + + :param language + :type language:label + ''' + def __init__( self , inherited0__assigned_class , inherited1__attribute_name , inherited2__role , items, ): + attribute_classification_assignment.__init__(self , inherited0__assigned_class , inherited1__attribute_name , inherited2__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'attribute_language_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + + @apply + def language(): + def fget( self ): + attribute_eval = self.self.attribute_classification_assignment.self.assigned_class.self.name + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument language is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.attribute_classification_assignment.self.role.self.name == ['primary','translated']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (('AUTOMOTIVE_DESIGN.' + 'LANGUAGE') == TYPEOF(self.self.attribute_classification_assignment.self.assigned_class)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY element_delivery # +#################### +class element_delivery(action): + '''Entity element_delivery definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__chosen_method , ): + action.__init__(self , inherited0__name , inherited1__description , inherited2__chosen_method , ) + def wr1(self): + eval_wr1_wr = ((SIZEOF(None) == 1) and (SIZEOF(None) == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.APPLIED_ORGANIZATION_ASSIGNMENT.ITEMS')) == 1) and (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ACTION_PROPERTY.DEFINITION')) == 1) and (SIZEOF(None) == 1)) and (SIZEOF(None) == 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ACTION_RELATIONSHIP.RELATING_ACTION')) + SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ACTION_RELATIONSHIP.RELATED_ACTION'))) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY edge_based_wireframe_shape_representation # +#################### +class edge_based_wireframe_shape_representation(shape_representation): + '''Entity edge_based_wireframe_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) >= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 0) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (self.self.context_of_items.self.geometric_representation_context.self.coordinate_space_dimension == 3) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + +#################### + # ENTITY derived_unit_element # +#################### +class derived_unit_element(BaseEntityClass): + '''Entity derived_unit_element definition. + + :param unit + :type unit:named_unit + + :param exponent + :type exponent:REAL + ''' + def __init__( self , unit,exponent, ): + self.unit = unit + self.exponent = exponent + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unit is mantatory and can not be set to None') + if not check_type(value,named_unit): + self._unit = named_unit(value) + else: + self._unit = value + return property(**locals()) + + @apply + def exponent(): + def fget( self ): + return self._exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._exponent = REAL(value) + else: + self._exponent = value + return property(**locals()) + +#################### + # ENTITY geometrically_bounded_wireframe_shape_representation # +#################### +class geometrically_bounded_wireframe_shape_representation(shape_representation): + '''Entity geometrically_bounded_wireframe_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) >= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY sliding_curve_pair_value # +#################### +class sliding_curve_pair_value(pair_value): + '''Entity sliding_curve_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:sliding_curve_pair + + :param actual_point_on_curve_1 + :type actual_point_on_curve_1:point_on_curve + + :param actual_point_on_curve_2 + :type actual_point_on_curve_2:point_on_curve + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_point_on_curve_1,actual_point_on_curve_2, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_point_on_curve_1 = actual_point_on_curve_1 + self.actual_point_on_curve_2 = actual_point_on_curve_2 + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,sliding_curve_pair): + self._pair_value_applies_to_pair = sliding_curve_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_point_on_curve_1(): + def fget( self ): + return self._actual_point_on_curve_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_point_on_curve_1 is mantatory and can not be set to None') + if not check_type(value,point_on_curve): + self._actual_point_on_curve_1 = point_on_curve(value) + else: + self._actual_point_on_curve_1 = value + return property(**locals()) + + @apply + def actual_point_on_curve_2(): + def fget( self ): + return self._actual_point_on_curve_2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_point_on_curve_2 is mantatory and can not be set to None') + if not check_type(value,point_on_curve): + self._actual_point_on_curve_2 = point_on_curve(value) + else: + self._actual_point_on_curve_2 = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.pair_value.self.applies_to_pair.self.planar_curve_pair.self.curve_1 == self.actual_point_on_curve_1.self.basis_curve) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.pair_value.self.applies_to_pair.self.planar_curve_pair.self.curve_2 == self.actual_point_on_curve_2.self.basis_curve) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY linear_dimension # +#################### +class linear_dimension(dimension_curve_directed_callout): + '''Entity linear_dimension definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + dimension_curve_directed_callout.__init__(self , inherited0__name , inherited1__contents , ) + +#################### + # ENTITY resource_property # +#################### +class resource_property(BaseEntityClass): + '''Entity resource_property definition. + + :param name + :type name:label + + :param description + :type description:text + + :param resource + :type resource:characterized_resource_definition + ''' + def __init__( self , name,description,resource, ): + self.name = name + self.description = description + self.resource = resource + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def resource(): + def fget( self ): + return self._resource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument resource is mantatory and can not be set to None') + if not check_type(value,characterized_resource_definition): + self._resource = characterized_resource_definition(value) + else: + self._resource = value + return property(**locals()) + +#################### + # ENTITY roundness_tolerance # +#################### +class roundness_tolerance(geometric_tolerance): + '''Entity roundness_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + def wr1(self): + eval_wr1_wr = ( not (('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE') == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY seam_curve # +#################### +class seam_curve(surface_curve): + '''Entity seam_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__curve_3d , inherited2__associated_geometry , inherited3__master_representation , ): + surface_curve.__init__(self , inherited0__name , inherited1__curve_3d , inherited2__associated_geometry , inherited3__master_representation , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.surface_curve.self.associated_geometry) == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (associated_surface(self.self.surface_curve.self.associated_geometry[1]) == associated_surface(self.self.surface_curve.self.associated_geometry[2])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(self.self.surface_curve.self.associated_geometry[1])) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(self.self.surface_curve.self.associated_geometry[2])) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY datum_target_callout # +#################### +class datum_target_callout(draughting_callout): + '''Entity datum_target_callout definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + +#################### + # ENTITY length_function # +#################### +class length_function(numeric_expression,unary_generic_expression): + '''Entity length_function definition. + + :param unary_generic_expression_operand + :type unary_generic_expression_operand:string_expression + ''' + def __init__( self , inherited0__operand , unary_generic_expression_operand, ): + numeric_expression.__init__(self , ) + unary_generic_expression.__init__(self , inherited0__operand , ) + self.unary_generic_expression_operand = unary_generic_expression_operand + + @apply + def unary_generic_expression_operand(): + def fget( self ): + return self._unary_generic_expression_operand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unary_generic_expression_operand is mantatory and can not be set to None') + if not check_type(value,string_expression): + self._unary_generic_expression_operand = string_expression(value) + else: + self._unary_generic_expression_operand = value + return property(**locals()) + +#################### + # ENTITY axis2_placement_3d # +#################### +class axis2_placement_3d(placement): + '''Entity axis2_placement_3d definition. + + :param axis + :type axis:direction + + :param ref_direction + :type ref_direction:direction + + :param p + :type p:LIST(3,3,'direction', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__location , axis,ref_direction, ): + placement.__init__(self , inherited0__name , inherited1__location , ) + self.axis = axis + self.ref_direction = ref_direction + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,direction): + self._axis = direction(value) + else: + self._axis = value + else: + self._axis = value + return property(**locals()) + + @apply + def ref_direction(): + def fget( self ): + return self._ref_direction + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,direction): + self._ref_direction = direction(value) + else: + self._ref_direction = value + else: + self._ref_direction = value + return property(**locals()) + + @apply + def p(): + def fget( self ): + attribute_eval = build_axes(self.axis,self.ref_direction) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument p is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.placement.self.location.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not EXISTS(self.axis)) or (self.axis.self.dim == 3)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not EXISTS(self.ref_direction)) or (self.ref_direction.self.dim == 3)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((( not EXISTS(self.axis)) or ( not EXISTS(self.ref_direction))) or (cross_product(self.axis,self.ref_direction).self.magnitude > 0)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY datum # +#################### +class datum(shape_aspect): + '''Entity datum definition. + + :param identification + :type identification:identifier + + :param established_by_relationships + :type established_by_relationships:SET(1,None,'shape_aspect_relationship', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , identification, ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + self.identification = identification + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument identification is mantatory and can not be set to None') + if not check_type(value,identifier): + self._identification = identifier(value) + else: + self._identification = value + return property(**locals()) + + @apply + def established_by_relationships(): + def fget( self ): + return self._established_by_relationships + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument established_by_relationships is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY interpolated_configuration_sequence # +#################### +class interpolated_configuration_sequence(BaseEntityClass): + '''Entity interpolated_configuration_sequence definition. + + :param interpolation + :type interpolation:SET(1,None,'configuration_interpolation', scope = schema_scope) + ''' + def __init__( self , interpolation, ): + self.interpolation = interpolation + + @apply + def interpolation(): + def fget( self ): + return self._interpolation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument interpolation is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'configuration_interpolation', scope = schema_scope)): + self._interpolation = SET(value) + else: + self._interpolation = value + return property(**locals()) + +#################### + # ENTITY rational_b_spline_surface # +#################### +class rational_b_spline_surface(b_spline_surface): + '''Entity rational_b_spline_surface definition. + + :param weights_data + :type weights_data:LIST(2,None,LIST(2,None,'REAL', scope = schema_scope)) + + :param weights + :type weights:ARRAY(0,u_upper,ARRAY(0,v_upper,'REAL', scope = schema_scope)) + ''' + def __init__( self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , weights_data, ): + b_spline_surface.__init__(self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , ) + self.weights_data = weights_data + + @apply + def weights_data(): + def fget( self ): + return self._weights_data + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument weights_data is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,LIST(2,None,'REAL', scope = schema_scope))): + self._weights_data = LIST(value) + else: + self._weights_data = value + return property(**locals()) + + @apply + def weights(): + def fget( self ): + attribute_eval = make_array_of_array(self.weights_data,0,self.u_upper,0,self.v_upper) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument weights is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((SIZEOF(self.weights_data) == SIZEOF(self.self.b_spline_surface.self.control_points_list)) and (SIZEOF(self.weights_data[1]) == SIZEOF(self.self.b_spline_surface.self.control_points_list[1]))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = surface_weights_positive(self) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY configuration_design # +#################### +class configuration_design(BaseEntityClass): + '''Entity configuration_design definition. + + :param configuration + :type configuration:configuration_item + + :param design + :type design:configuration_design_item + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , configuration,design, ): + self.configuration = configuration + self.design = design + + @apply + def configuration(): + def fget( self ): + return self._configuration + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument configuration is mantatory and can not be set to None') + if not check_type(value,configuration_item): + self._configuration = configuration_item(value) + else: + self._configuration = value + return property(**locals()) + + @apply + def design(): + def fget( self ): + return self._design + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument design is mantatory and can not be set to None') + if not check_type(value,configuration_design_item): + self._design = configuration_design_item(value) + else: + self._design = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY defined_character_glyph # +#################### +class defined_character_glyph(geometric_representation_item): + '''Entity defined_character_glyph definition. + + :param definition + :type definition:defined_glyph_select + + :param placement + :type placement:axis2_placement + ''' + def __init__( self , inherited0__name , definition,placement, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.definition = definition + self.placement = placement + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definition is mantatory and can not be set to None') + if not check_type(value,defined_glyph_select): + self._definition = defined_glyph_select(value) + else: + self._definition = value + return property(**locals()) + + @apply + def placement(): + def fget( self ): + return self._placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placement is mantatory and can not be set to None') + if not check_type(value,axis2_placement): + self._placement = axis2_placement(value) + else: + self._placement = value + return property(**locals()) + +#################### + # ENTITY drawing_sheet_revision # +#################### +class drawing_sheet_revision(presentation_area): + '''Entity drawing_sheet_revision definition. + + :param revision_identifier + :type revision_identifier:identifier + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , inherited3__representation_context_of_items , revision_identifier, ): + presentation_area.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , inherited3__representation_context_of_items , ) + self.revision_identifier = revision_identifier + + @apply + def revision_identifier(): + def fget( self ): + return self._revision_identifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument revision_identifier is mantatory and can not be set to None') + if not check_type(value,identifier): + self._revision_identifier = identifier(value) + else: + self._revision_identifier = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY torus # +#################### +class torus(geometric_representation_item): + '''Entity torus definition. + + :param position + :type position:axis1_placement + + :param major_radius + :type major_radius:positive_length_measure + + :param minor_radius + :type minor_radius:positive_length_measure + ''' + def __init__( self , inherited0__name , position,major_radius,minor_radius, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.position = position + self.major_radius = major_radius + self.minor_radius = minor_radius + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,axis1_placement): + self._position = axis1_placement(value) + else: + self._position = value + return property(**locals()) + + @apply + def major_radius(): + def fget( self ): + return self._major_radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument major_radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._major_radius = positive_length_measure(value) + else: + self._major_radius = value + return property(**locals()) + + @apply + def minor_radius(): + def fget( self ): + return self._minor_radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument minor_radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._minor_radius = positive_length_measure(value) + else: + self._minor_radius = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.major_radius > self.minor_radius) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY bead # +#################### +class bead(feature_definition): + '''Entity bead definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY process_product_association # +#################### +class process_product_association(BaseEntityClass): + '''Entity process_product_association definition. + + :param name + :type name:label + + :param description + :type description:text + + :param defined_product + :type defined_product:characterized_product_definition + + :param process + :type process:product_definition_process + ''' + def __init__( self , name,description,defined_product,process, ): + self.name = name + self.description = description + self.defined_product = defined_product + self.process = process + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def defined_product(): + def fget( self ): + return self._defined_product + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument defined_product is mantatory and can not be set to None') + if not check_type(value,characterized_product_definition): + self._defined_product = characterized_product_definition(value) + else: + self._defined_product = value + return property(**locals()) + + @apply + def process(): + def fget( self ): + return self._process + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument process is mantatory and can not be set to None') + if not check_type(value,product_definition_process): + self._process = product_definition_process(value) + else: + self._process = value + return property(**locals()) + +#################### + # ENTITY product_concept_relationship # +#################### +class product_concept_relationship(BaseEntityClass): + '''Entity product_concept_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_product_concept + :type relating_product_concept:product_concept + + :param related_product_concept + :type related_product_concept:product_concept + ''' + def __init__( self , name,description,relating_product_concept,related_product_concept, ): + self.name = name + self.description = description + self.relating_product_concept = relating_product_concept + self.related_product_concept = related_product_concept + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_product_concept(): + def fget( self ): + return self._relating_product_concept + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_product_concept is mantatory and can not be set to None') + if not check_type(value,product_concept): + self._relating_product_concept = product_concept(value) + else: + self._relating_product_concept = value + return property(**locals()) + + @apply + def related_product_concept(): + def fget( self ): + return self._related_product_concept + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_product_concept is mantatory and can not be set to None') + if not check_type(value,product_concept): + self._related_product_concept = product_concept(value) + else: + self._related_product_concept = value + return property(**locals()) + +#################### + # ENTITY gear_pair_value # +#################### +class gear_pair_value(pair_value): + '''Entity gear_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:gear_pair + + :param actual_rotation_1 + :type actual_rotation_1:plane_angle_measure + + :param actual_rotation_2 + :type actual_rotation_2:plane_angle_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_rotation_1, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_rotation_1 = actual_rotation_1 + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,gear_pair): + self._pair_value_applies_to_pair = gear_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_rotation_1(): + def fget( self ): + return self._actual_rotation_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_rotation_1 is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._actual_rotation_1 = plane_angle_measure(value) + else: + self._actual_rotation_1 = value + return property(**locals()) + + @apply + def actual_rotation_2(): + def fget( self ): + attribute_eval = ((-self.actual_rotation_1) * self.self.pair_value.self.applies_to_pair.self.gear_pair.self.gear_ratio) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument actual_rotation_2 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY annotation_text_occurrence # +#################### +class annotation_text_occurrence(annotation_occurrence): + '''Entity annotation_text_occurrence definition. + + :param styled_item_item + :type styled_item_item:annotation_text_occurrence_item + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , styled_item_item, ): + annotation_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , ) + self.styled_item_item = styled_item_item + + @apply + def styled_item_item(): + def fget( self ): + return self._styled_item_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styled_item_item is mantatory and can not be set to None') + if not check_type(value,annotation_text_occurrence_item): + self._styled_item_item = annotation_text_occurrence_item(value) + else: + self._styled_item_item = value + return property(**locals()) + +#################### + # ENTITY common_datum # +#################### +class common_datum(composite_shape_aspect,datum): + '''Entity common_datum definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , inherited4__name , inherited5__description , inherited6__of_shape , inherited7__product_definitional , inherited8__identification , ): + composite_shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + datum.__init__(self , inherited4__name , inherited5__description , inherited6__of_shape , inherited7__product_definitional , inherited8__identification , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.component_relationships) == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY dimension_curve # +#################### +class dimension_curve(annotation_curve_occurrence): + '''Entity dimension_curve definition. + ''' + def __init__( self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , ): + annotation_curve_occurrence.__init__(self , inherited0__name , inherited1__styles , inherited2__item , inherited3__styled_item_item , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) <= 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) >= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY luminous_intensity_unit # +#################### +class luminous_intensity_unit(named_unit): + '''Entity luminous_intensity_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 0) and (self.self.named_unit.self.dimensions.self.mass_exponent == 0)) and (self.self.named_unit.self.dimensions.self.time_exponent == 0)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 0)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 0)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 0)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY cylindrical_pair # +#################### +class cylindrical_pair(kinematic_pair): + '''Entity cylindrical_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + +#################### + # ENTITY organization # +#################### +class organization(BaseEntityClass): + '''Entity organization definition. + + :param id + :type id:identifier + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , id,name,description, ): + self.id = id + self.name = name + self.description = description + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,identifier): + self._id = identifier(value) + else: + self._id = value + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY rack_and_pinion_pair_range # +#################### +class rack_and_pinion_pair_range(simple_pair_range): + '''Entity rack_and_pinion_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:rack_and_pinion_pair + + :param lower_limit_rack_displacement + :type lower_limit_rack_displacement:translational_range_measure + + :param upper_limit_rack_displacement + :type upper_limit_rack_displacement:translational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,lower_limit_rack_displacement,upper_limit_rack_displacement, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.lower_limit_rack_displacement = lower_limit_rack_displacement + self.upper_limit_rack_displacement = upper_limit_rack_displacement + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,rack_and_pinion_pair): + self._simple_pair_range_applies_to_pair = rack_and_pinion_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def lower_limit_rack_displacement(): + def fget( self ): + return self._lower_limit_rack_displacement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_rack_displacement is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._lower_limit_rack_displacement = translational_range_measure(value) + else: + self._lower_limit_rack_displacement = value + return property(**locals()) + + @apply + def upper_limit_rack_displacement(): + def fget( self ): + return self._upper_limit_rack_displacement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_rack_displacement is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._upper_limit_rack_displacement = translational_range_measure(value) + else: + self._upper_limit_rack_displacement = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_rack_displacement)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_rack_displacement))) XOR (self.lower_limit_rack_displacement < self.upper_limit_rack_displacement)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY dimension_callout # +#################### +class dimension_callout(draughting_callout): + '''Entity dimension_callout definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.LEADER_DIRECTED_CALLOUT' == TYPEOF(self)) XOR (SIZEOF(None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (('AUTOMOTIVE_DESIGN.PROJECTION_DIRECTED_CALLOUT' == TYPEOF(self)) XOR (SIZEOF(None) == 0)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (('AUTOMOTIVE_DESIGN.DIMENSION_CURVE_DIRECTED_CALLOUT' == TYPEOF(self)) XOR (SIZEOF(None) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY location_shape_representation # +#################### +class location_shape_representation(shape_representation): + '''Entity location_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.items) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY multi_language_attribute_assignment # +#################### +class multi_language_attribute_assignment(attribute_value_assignment): + '''Entity multi_language_attribute_assignment definition. + + :param items + :type items:SET(1,None,'multi_language_attribute_item', scope = schema_scope) + + :param language + :type language:label + ''' + def __init__( self , inherited0__attribute_name , inherited1__attribute_value , inherited2__role , items, ): + attribute_value_assignment.__init__(self , inherited0__attribute_name , inherited1__attribute_value , inherited2__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'multi_language_attribute_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + + @apply + def language(): + def fget( self ): + attribute_eval = get_multi_language(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument language is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.attribute_value_assignment.self.role.self.name == 'alternate language') + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS')) == 1) and (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY rep_item_group # +#################### +class rep_item_group(group,representation_item): + '''Entity rep_item_group definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__name , ): + group.__init__(self , inherited0__name , inherited1__description , ) + representation_item.__init__(self , inherited2__name , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.PRESENTATION_LAYER_ASSIGNMENT.ASSIGNED_ITEMS')) > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_REPRESENTATION_ITEM','AUTOMOTIVE_DESIGN.' + 'TOPOLOGICAL_REPRESENTATION_ITEM','AUTOMOTIVE_DESIGN.' + 'MAPPED_ITEM','AUTOMOTIVE_DESIGN.' + 'STYLED_ITEM'] * TYPEOF(self)) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY colour_rgb # +#################### +class colour_rgb(colour_specification): + '''Entity colour_rgb definition. + + :param red + :type red:REAL + + :param green + :type green:REAL + + :param blue + :type blue:REAL + ''' + def __init__( self , inherited0__name , red,green,blue, ): + colour_specification.__init__(self , inherited0__name , ) + self.red = red + self.green = green + self.blue = blue + + @apply + def red(): + def fget( self ): + return self._red + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument red is mantatory and can not be set to None') + if not check_type(value,REAL): + self._red = REAL(value) + else: + self._red = value + return property(**locals()) + + @apply + def green(): + def fget( self ): + return self._green + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument green is mantatory and can not be set to None') + if not check_type(value,REAL): + self._green = REAL(value) + else: + self._green = value + return property(**locals()) + + @apply + def blue(): + def fget( self ): + return self._blue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument blue is mantatory and can not be set to None') + if not check_type(value,REAL): + self._blue = REAL(value) + else: + self._blue = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((0 <= self.red) and (self.red <= 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((0 <= self.green) and (self.green <= 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((0 <= self.blue) and (self.blue <= 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY real_defined_function # +#################### +class real_defined_function(numeric_defined_function): + '''Entity real_defined_function definition. + ''' + def __init__( self , ): + numeric_defined_function.__init__(self , ) + +#################### + # ENTITY referenced_modified_datum # +#################### +class referenced_modified_datum(datum_reference): + '''Entity referenced_modified_datum definition. + + :param modifier + :type modifier:limit_condition + ''' + def __init__( self , inherited0__precedence , inherited1__referenced_datum , modifier, ): + datum_reference.__init__(self , inherited0__precedence , inherited1__referenced_datum , ) + self.modifier = modifier + + @apply + def modifier(): + def fget( self ): + return self._modifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument modifier is mantatory and can not be set to None') + if not check_type(value,limit_condition): + self._modifier = limit_condition(value) + else: + self._modifier = value + return property(**locals()) + +#################### + # ENTITY mult_expression # +#################### +class mult_expression(multiple_arity_numeric_expression): + '''Entity mult_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ): + multiple_arity_numeric_expression.__init__(self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ) + +#################### + # ENTITY approximation_tolerance_parameter # +#################### +class approximation_tolerance_parameter(founded_item): + '''Entity approximation_tolerance_parameter definition. + + :param tolerances + :type tolerances:SET(1,2,'tolerance_parameter_select', scope = schema_scope) + ''' + def __init__( self , tolerances, ): + founded_item.__init__(self , ) + self.tolerances = tolerances + + @apply + def tolerances(): + def fget( self ): + return self._tolerances + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tolerances is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'tolerance_parameter_select', scope = schema_scope)): + self._tolerances = SET(value) + else: + self._tolerances = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((HIINDEX(self.self.tolerances) == 1) XOR (TYPEOF(self.self.tolerances[1]) != TYPEOF(self.self.tolerances[2]))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY b_spline_surface_with_knots # +#################### +class b_spline_surface_with_knots(b_spline_surface): + '''Entity b_spline_surface_with_knots definition. + + :param u_multiplicities + :type u_multiplicities:LIST(2,None,'INTEGER', scope = schema_scope) + + :param v_multiplicities + :type v_multiplicities:LIST(2,None,'INTEGER', scope = schema_scope) + + :param u_knots + :type u_knots:LIST(2,None,'REAL', scope = schema_scope) + + :param v_knots + :type v_knots:LIST(2,None,'REAL', scope = schema_scope) + + :param knot_spec + :type knot_spec:knot_type + + :param knot_u_upper + :type knot_u_upper:INTEGER + + :param knot_v_upper + :type knot_v_upper:INTEGER + ''' + def __init__( self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , u_multiplicities,v_multiplicities,u_knots,v_knots,knot_spec, ): + b_spline_surface.__init__(self , inherited0__name , inherited1__u_degree , inherited2__v_degree , inherited3__control_points_list , inherited4__surface_form , inherited5__u_closed , inherited6__v_closed , inherited7__self_intersect , ) + self.u_multiplicities = u_multiplicities + self.v_multiplicities = v_multiplicities + self.u_knots = u_knots + self.v_knots = v_knots + self.knot_spec = knot_spec + + @apply + def u_multiplicities(): + def fget( self ): + return self._u_multiplicities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u_multiplicities is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'INTEGER', scope = schema_scope)): + self._u_multiplicities = LIST(value) + else: + self._u_multiplicities = value + return property(**locals()) + + @apply + def v_multiplicities(): + def fget( self ): + return self._v_multiplicities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v_multiplicities is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'INTEGER', scope = schema_scope)): + self._v_multiplicities = LIST(value) + else: + self._v_multiplicities = value + return property(**locals()) + + @apply + def u_knots(): + def fget( self ): + return self._u_knots + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u_knots is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._u_knots = LIST(value) + else: + self._u_knots = value + return property(**locals()) + + @apply + def v_knots(): + def fget( self ): + return self._v_knots + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v_knots is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._v_knots = LIST(value) + else: + self._v_knots = value + return property(**locals()) + + @apply + def knot_spec(): + def fget( self ): + return self._knot_spec + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument knot_spec is mantatory and can not be set to None') + if not check_type(value,knot_type): + self._knot_spec = knot_type(value) + else: + self._knot_spec = value + return property(**locals()) + + @apply + def knot_u_upper(): + def fget( self ): + attribute_eval = SIZEOF(self.u_knots) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument knot_u_upper is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def knot_v_upper(): + def fget( self ): + attribute_eval = SIZEOF(self.v_knots) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument knot_v_upper is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = constraints_param_b_spline(self.self.b_spline_surface.self.u_degree,self.knot_u_upper,self.self.b_spline_surface.self.u_upper,self.u_multiplicities,self.u_knots) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = constraints_param_b_spline(self.self.b_spline_surface.self.v_degree,self.knot_v_upper,self.self.b_spline_surface.self.v_upper,self.v_multiplicities,self.v_knots) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(self.u_multiplicities) == self.knot_u_upper) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(self.v_multiplicities) == self.knot_v_upper) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY int_value_function # +#################### +class int_value_function(value_function): + '''Entity int_value_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + value_function.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY kinematic_path # +#################### +class kinematic_path(representation_item): + '''Entity kinematic_path definition. + ''' + def __init__( self , inherited0__name , ): + representation_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY class_usage_effectivity_context_assignment # +#################### +class class_usage_effectivity_context_assignment(effectivity_context_assignment): + '''Entity class_usage_effectivity_context_assignment definition. + + :param items + :type items:SET(1,None,'class_usage_effectivity_context_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_effectivity_assignment , inherited1__role , items, ): + effectivity_context_assignment.__init__(self , inherited0__assigned_effectivity_assignment , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'class_usage_effectivity_context_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.role.self.name == 'class usage influence') + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((((('AUTOMOTIVE_DESIGN.' + 'APPLIED_EFFECTIVITY_ASSIGNMENT') == TYPEOF(self.self.assigned_effectivity_assignment)) and (SIZEOF(TYPEOF(self.self.assigned_effectivity_assignment.self.assigned_effectivity)) == 1)) and (self.self.assigned_effectivity_assignment.self.assigned_effectivity.self.id == 'class usage')) and (SIZEOF(None) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY resulting_path # +#################### +class resulting_path(motion_link_relationship): + '''Entity resulting_path definition. + + :param controlling_joints + :type controlling_joints:SET(1,None,'kinematic_joint', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , inherited4__representation_relationship_rep_1 , inherited5__representation_relationship_rep_2 , inherited6__related_frame , controlling_joints, ): + motion_link_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , inherited4__representation_relationship_rep_1 , inherited5__representation_relationship_rep_2 , inherited6__related_frame , ) + self.controlling_joints = controlling_joints + + @apply + def controlling_joints(): + def fget( self ): + return self._controlling_joints + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument controlling_joints is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'kinematic_joint', scope = schema_scope)): + self._controlling_joints = SET(value) + else: + self._controlling_joints = value + return property(**locals()) + +#################### + # ENTITY effectivity_context_role # +#################### +class effectivity_context_role(BaseEntityClass): + '''Entity effectivity_context_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY face_shape_representation # +#################### +class face_shape_representation(shape_representation): + '''Entity face_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.items) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY modified_geometric_tolerance # +#################### +class modified_geometric_tolerance(geometric_tolerance): + '''Entity modified_geometric_tolerance definition. + + :param modifier + :type modifier:limit_condition + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , modifier, ): + geometric_tolerance.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , ) + self.modifier = modifier + + @apply + def modifier(): + def fget( self ): + return self._modifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument modifier is mantatory and can not be set to None') + if not check_type(value,limit_condition): + self._modifier = limit_condition(value) + else: + self._modifier = value + return property(**locals()) + +#################### + # ENTITY certification_type # +#################### +class certification_type(BaseEntityClass): + '''Entity certification_type definition. + + :param description + :type description:label + ''' + def __init__( self , description, ): + self.description = description + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,label): + self._description = label(value) + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY draughting_elements # +#################### +class draughting_elements(draughting_callout): + '''Entity draughting_elements definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not ('AUTOMOTIVE_DESIGN.DIMENSION_CURVE_DIRECTED_CALLOUT' == TYPEOF(self))) or (SIZEOF(None) <= 2)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) <= 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) <= 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY modified_pattern # +#################### +class modified_pattern(replicate_feature): + '''Entity modified_pattern definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + replicate_feature.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY point_on_surface_pair_range # +#################### +class point_on_surface_pair_range(simple_pair_range): + '''Entity point_on_surface_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:point_on_surface_pair + + :param range_on_pair_surface + :type range_on_pair_surface:rectangular_trimmed_surface + + :param lower_limit_yaw + :type lower_limit_yaw:rotational_range_measure + + :param upper_limit_yaw + :type upper_limit_yaw:rotational_range_measure + + :param lower_limit_pitch + :type lower_limit_pitch:rotational_range_measure + + :param upper_limit_pitch + :type upper_limit_pitch:rotational_range_measure + + :param lower_limit_roll + :type lower_limit_roll:rotational_range_measure + + :param upper_limit_roll + :type upper_limit_roll:rotational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,range_on_pair_surface,lower_limit_yaw,upper_limit_yaw,lower_limit_pitch,upper_limit_pitch,lower_limit_roll,upper_limit_roll, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.range_on_pair_surface = range_on_pair_surface + self.lower_limit_yaw = lower_limit_yaw + self.upper_limit_yaw = upper_limit_yaw + self.lower_limit_pitch = lower_limit_pitch + self.upper_limit_pitch = upper_limit_pitch + self.lower_limit_roll = lower_limit_roll + self.upper_limit_roll = upper_limit_roll + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,point_on_surface_pair): + self._simple_pair_range_applies_to_pair = point_on_surface_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def range_on_pair_surface(): + def fget( self ): + return self._range_on_pair_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument range_on_pair_surface is mantatory and can not be set to None') + if not check_type(value,rectangular_trimmed_surface): + self._range_on_pair_surface = rectangular_trimmed_surface(value) + else: + self._range_on_pair_surface = value + return property(**locals()) + + @apply + def lower_limit_yaw(): + def fget( self ): + return self._lower_limit_yaw + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_yaw is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_yaw = rotational_range_measure(value) + else: + self._lower_limit_yaw = value + return property(**locals()) + + @apply + def upper_limit_yaw(): + def fget( self ): + return self._upper_limit_yaw + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_yaw is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_yaw = rotational_range_measure(value) + else: + self._upper_limit_yaw = value + return property(**locals()) + + @apply + def lower_limit_pitch(): + def fget( self ): + return self._lower_limit_pitch + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_pitch is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_pitch = rotational_range_measure(value) + else: + self._lower_limit_pitch = value + return property(**locals()) + + @apply + def upper_limit_pitch(): + def fget( self ): + return self._upper_limit_pitch + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_pitch is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_pitch = rotational_range_measure(value) + else: + self._upper_limit_pitch = value + return property(**locals()) + + @apply + def lower_limit_roll(): + def fget( self ): + return self._lower_limit_roll + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_roll is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_roll = rotational_range_measure(value) + else: + self._lower_limit_roll = value + return property(**locals()) + + @apply + def upper_limit_roll(): + def fget( self ): + return self._upper_limit_roll + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_roll is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_roll = rotational_range_measure(value) + else: + self._upper_limit_roll = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.simple_pair_range.self.applies_to_pair.self.point_on_surface_pair.self.pair_surface == self.range_on_pair_surface.self.basis_surface) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_yaw)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_yaw))) XOR (self.lower_limit_yaw < self.upper_limit_yaw)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_pitch)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_pitch))) XOR (self.lower_limit_pitch < self.upper_limit_pitch)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_roll)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_roll))) XOR (self.lower_limit_roll < self.upper_limit_roll)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY oriented_path # +#################### +class oriented_path(path): + '''Entity oriented_path definition. + + :param path_element + :type path_element:path + + :param orientation + :type orientation:BOOLEAN + + :param path_edge_list + :type path_edge_list:LIST(1,None,'oriented_edge', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__edge_list , path_element,orientation, ): + path.__init__(self , inherited0__name , inherited1__edge_list , ) + self.path_element = path_element + self.orientation = orientation + + @apply + def path_element(): + def fget( self ): + return self._path_element + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument path_element is mantatory and can not be set to None') + if not check_type(value,path): + self._path_element = path(value) + else: + self._path_element = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def path_edge_list(): + def fget( self ): + attribute_eval = conditional_reverse(self.self.orientation,self.self.path_element.self.edge_list) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument path_edge_list is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('AUTOMOTIVE_DESIGN.ORIENTED_PATH' == TYPEOF(self.self.path_element))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY face_based_surface_model # +#################### +class face_based_surface_model(geometric_representation_item): + '''Entity face_based_surface_model definition. + + :param fbsm_faces + :type fbsm_faces:SET(1,None,'connected_face_set', scope = schema_scope) + ''' + def __init__( self , inherited0__name , fbsm_faces, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.fbsm_faces = fbsm_faces + + @apply + def fbsm_faces(): + def fget( self ): + return self._fbsm_faces + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fbsm_faces is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'connected_face_set', scope = schema_scope)): + self._fbsm_faces = SET(value) + else: + self._fbsm_faces = value + return property(**locals()) + +#################### + # ENTITY kinematic_control # +#################### +class kinematic_control(BaseEntityClass): + '''Entity kinematic_control definition. + + :param controlled_mechanism + :type controlled_mechanism:mechanism + + :param contained_kinematic_programs + :type contained_kinematic_programs:SET(1,None,'kinematic_analysis_definition', scope = schema_scope) + ''' + def __init__( self , controlled_mechanism,contained_kinematic_programs, ): + self.controlled_mechanism = controlled_mechanism + self.contained_kinematic_programs = contained_kinematic_programs + + @apply + def controlled_mechanism(): + def fget( self ): + return self._controlled_mechanism + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument controlled_mechanism is mantatory and can not be set to None') + if not check_type(value,mechanism): + self._controlled_mechanism = mechanism(value) + else: + self._controlled_mechanism = value + return property(**locals()) + + @apply + def contained_kinematic_programs(): + def fget( self ): + return self._contained_kinematic_programs + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument contained_kinematic_programs is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'kinematic_analysis_definition', scope = schema_scope)): + self._contained_kinematic_programs = SET(value) + else: + self._contained_kinematic_programs = value + return property(**locals()) + +#################### + # ENTITY measure_qualification # +#################### +class measure_qualification(BaseEntityClass): + '''Entity measure_qualification definition. + + :param name + :type name:label + + :param description + :type description:text + + :param qualified_measure + :type qualified_measure:measure_with_unit + + :param qualifiers + :type qualifiers:SET(1,None,'value_qualifier', scope = schema_scope) + ''' + def __init__( self , name,description,qualified_measure,qualifiers, ): + self.name = name + self.description = description + self.qualified_measure = qualified_measure + self.qualifiers = qualifiers + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def qualified_measure(): + def fget( self ): + return self._qualified_measure + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument qualified_measure is mantatory and can not be set to None') + if not check_type(value,measure_with_unit): + self._qualified_measure = measure_with_unit(value) + else: + self._qualified_measure = value + return property(**locals()) + + @apply + def qualifiers(): + def fget( self ): + return self._qualifiers + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument qualifiers is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'value_qualifier', scope = schema_scope)): + self._qualifiers = SET(value) + else: + self._qualifiers = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) < 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ( not ('AUTOMOTIVE_DESIGN.REPRESENTATION_ITEM' == TYPEOF(self.self.measure_qualification.self.qualified_measure))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY security_classification # +#################### +class security_classification(BaseEntityClass): + '''Entity security_classification definition. + + :param name + :type name:label + + :param purpose + :type purpose:text + + :param security_level + :type security_level:security_classification_level + ''' + def __init__( self , name,purpose,security_level, ): + self.name = name + self.purpose = purpose + self.security_level = security_level + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument purpose is mantatory and can not be set to None') + if not check_type(value,text): + self._purpose = text(value) + else: + self._purpose = value + return property(**locals()) + + @apply + def security_level(): + def fget( self ): + return self._security_level + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument security_level is mantatory and can not be set to None') + if not check_type(value,security_classification_level): + self._security_level = security_classification_level(value) + else: + self._security_level = value + return property(**locals()) + +#################### + # ENTITY standard_uncertainty # +#################### +class standard_uncertainty(uncertainty_qualifier): + '''Entity standard_uncertainty definition. + + :param uncertainty_value + :type uncertainty_value:REAL + ''' + def __init__( self , inherited0__measure_name , inherited1__description , uncertainty_value, ): + uncertainty_qualifier.__init__(self , inherited0__measure_name , inherited1__description , ) + self.uncertainty_value = uncertainty_value + + @apply + def uncertainty_value(): + def fget( self ): + return self._uncertainty_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument uncertainty_value is mantatory and can not be set to None') + if not check_type(value,REAL): + self._uncertainty_value = REAL(value) + else: + self._uncertainty_value = value + return property(**locals()) + +#################### + # ENTITY vertex_loop # +#################### +class vertex_loop(loop): + '''Entity vertex_loop definition. + + :param loop_vertex + :type loop_vertex:vertex + ''' + def __init__( self , inherited0__name , loop_vertex, ): + loop.__init__(self , inherited0__name , ) + self.loop_vertex = loop_vertex + + @apply + def loop_vertex(): + def fget( self ): + return self._loop_vertex + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument loop_vertex is mantatory and can not be set to None') + if not check_type(value,vertex): + self._loop_vertex = vertex(value) + else: + self._loop_vertex = value + return property(**locals()) + +#################### + # ENTITY annotation_occurrence_relationship # +#################### +class annotation_occurrence_relationship(BaseEntityClass): + '''Entity annotation_occurrence_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_annotation_occurrence + :type relating_annotation_occurrence:annotation_occurrence + + :param related_annotation_occurrence + :type related_annotation_occurrence:annotation_occurrence + ''' + def __init__( self , name,description,relating_annotation_occurrence,related_annotation_occurrence, ): + self.name = name + self.description = description + self.relating_annotation_occurrence = relating_annotation_occurrence + self.related_annotation_occurrence = related_annotation_occurrence + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def relating_annotation_occurrence(): + def fget( self ): + return self._relating_annotation_occurrence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_annotation_occurrence is mantatory and can not be set to None') + if not check_type(value,annotation_occurrence): + self._relating_annotation_occurrence = annotation_occurrence(value) + else: + self._relating_annotation_occurrence = value + return property(**locals()) + + @apply + def related_annotation_occurrence(): + def fget( self ): + return self._related_annotation_occurrence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_annotation_occurrence is mantatory and can not be set to None') + if not check_type(value,annotation_occurrence): + self._related_annotation_occurrence = annotation_occurrence(value) + else: + self._related_annotation_occurrence = value + return property(**locals()) + +#################### + # ENTITY annotation_occurrence_associativity # +#################### +class annotation_occurrence_associativity(annotation_occurrence_relationship): + '''Entity annotation_occurrence_associativity definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relating_annotation_occurrence , inherited3__related_annotation_occurrence , ): + annotation_occurrence_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__relating_annotation_occurrence , inherited3__related_annotation_occurrence , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(TYPEOF(self.self.related_annotation_occurrence) * ['AUTOMOTIVE_DESIGN.ANNOTATION_FILL_AREA_OCCURRENCE','AUTOMOTIVE_DESIGN.PROJECTION_CURVE','AUTOMOTIVE_DESIGN.LEADER_CURVE']) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY runout_zone_definition # +#################### +class runout_zone_definition(tolerance_zone_definition): + '''Entity runout_zone_definition definition. + + :param orientation + :type orientation:runout_zone_orientation + ''' + def __init__( self , inherited0__zone , inherited1__boundaries , orientation, ): + tolerance_zone_definition.__init__(self , inherited0__zone , inherited1__boundaries , ) + self.orientation = orientation + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,runout_zone_orientation): + self._orientation = runout_zone_orientation(value) + else: + self._orientation = value + return property(**locals()) + +#################### + # ENTITY applied_effectivity_assignment # +#################### +class applied_effectivity_assignment(effectivity_assignment): + '''Entity applied_effectivity_assignment definition. + + :param items + :type items:SET(1,None,'effectivity_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_effectivity , items, ): + effectivity_assignment.__init__(self , inherited0__assigned_effectivity , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'effectivity_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'LOT_EFFECTIVITY','AUTOMOTIVE_DESIGN.' + 'SERIAL_NUMBERED_EFFECTIVITY','AUTOMOTIVE_DESIGN.' + 'PRODUCT_DEFINITION_EFFECTIVITY'] * TYPEOF(self.self.assigned_effectivity)) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY approval_status # +#################### +class approval_status(BaseEntityClass): + '''Entity approval_status definition. + + :param name + :type name:label + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY cartesian_point # +#################### +class cartesian_point(point): + '''Entity cartesian_point definition. + + :param coordinates + :type coordinates:LIST(1,3,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__name , coordinates, ): + point.__init__(self , inherited0__name , ) + self.coordinates = coordinates + + @apply + def coordinates(): + def fget( self ): + return self._coordinates + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordinates is mantatory and can not be set to None') + if not check_type(value,LIST(1,3,'REAL', scope = schema_scope)): + self._coordinates = LIST(value) + else: + self._coordinates = value + return property(**locals()) + +#################### + # ENTITY curve_style_rendering # +#################### +class curve_style_rendering(BaseEntityClass): + '''Entity curve_style_rendering definition. + + :param rendering_method + :type rendering_method:shading_curve_method + + :param rendering_properties + :type rendering_properties:surface_rendering_properties + ''' + def __init__( self , rendering_method,rendering_properties, ): + self.rendering_method = rendering_method + self.rendering_properties = rendering_properties + + @apply + def rendering_method(): + def fget( self ): + return self._rendering_method + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rendering_method is mantatory and can not be set to None') + if not check_type(value,shading_curve_method): + self._rendering_method = shading_curve_method(value) + else: + self._rendering_method = value + return property(**locals()) + + @apply + def rendering_properties(): + def fget( self ): + return self._rendering_properties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rendering_properties is mantatory and can not be set to None') + if not check_type(value,surface_rendering_properties): + self._rendering_properties = surface_rendering_properties(value) + else: + self._rendering_properties = value + return property(**locals()) + +#################### + # ENTITY fully_constrained_pair # +#################### +class fully_constrained_pair(kinematic_pair): + '''Entity fully_constrained_pair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ): + kinematic_pair.__init__(self , inherited0__name , inherited1__description , inherited2__transform_item_1 , inherited3__transform_item_2 , inherited4__joint , ) + +#################### + # ENTITY pre_defined_marker # +#################### +class pre_defined_marker(pre_defined_item): + '''Entity pre_defined_marker definition. + ''' + def __init__( self , inherited0__name , ): + pre_defined_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY action_assignment # +#################### +class action_assignment(BaseEntityClass): + '''Entity action_assignment definition. + + :param assigned_action + :type assigned_action:action + + :param role + :type role:object_role + ''' + def __init__( self , assigned_action, ): + self.assigned_action = assigned_action + + @apply + def assigned_action(): + def fget( self ): + return self._assigned_action + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_action is mantatory and can not be set to None') + if not check_type(value,action): + self._assigned_action = action(value) + else: + self._assigned_action = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY composite_text_with_associated_curves # +#################### +class composite_text_with_associated_curves(composite_text): + '''Entity composite_text_with_associated_curves definition. + + :param associated_curves + :type associated_curves:SET(1,None,'curve', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__collected_text , associated_curves, ): + composite_text.__init__(self , inherited0__name , inherited1__collected_text , ) + self.associated_curves = associated_curves + + @apply + def associated_curves(): + def fget( self ): + return self._associated_curves + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument associated_curves is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'curve', scope = schema_scope)): + self._associated_curves = SET(value) + else: + self._associated_curves = value + return property(**locals()) + +#################### + # ENTITY compound_shape_representation # +#################### +class compound_shape_representation(shape_representation): + '''Entity compound_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_REPRESENTATION_CONTEXT') == TYPEOF(self.self.context_of_items)) and (self.self.context_of_items.self.geometric_representation_context.self.coordinate_space_dimension == 3)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) > 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY fill_area_style_tiles # +#################### +class fill_area_style_tiles(geometric_representation_item): + '''Entity fill_area_style_tiles definition. + + :param tiling_pattern + :type tiling_pattern:two_direction_repeat_factor + + :param tiles + :type tiles:SET(1,None,'fill_area_style_tile_shape_select', scope = schema_scope) + + :param tiling_scale + :type tiling_scale:positive_ratio_measure + ''' + def __init__( self , inherited0__name , tiling_pattern,tiles,tiling_scale, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.tiling_pattern = tiling_pattern + self.tiles = tiles + self.tiling_scale = tiling_scale + + @apply + def tiling_pattern(): + def fget( self ): + return self._tiling_pattern + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tiling_pattern is mantatory and can not be set to None') + if not check_type(value,two_direction_repeat_factor): + self._tiling_pattern = two_direction_repeat_factor(value) + else: + self._tiling_pattern = value + return property(**locals()) + + @apply + def tiles(): + def fget( self ): + return self._tiles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tiles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'fill_area_style_tile_shape_select', scope = schema_scope)): + self._tiles = SET(value) + else: + self._tiles = value + return property(**locals()) + + @apply + def tiling_scale(): + def fget( self ): + return self._tiling_scale + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tiling_scale is mantatory and can not be set to None') + if not check_type(value,positive_ratio_measure): + self._tiling_scale = positive_ratio_measure(value) + else: + self._tiling_scale = value + return property(**locals()) + +#################### + # ENTITY cos_function # +#################### +class cos_function(unary_function_call): + '''Entity cos_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY drawing_sheet_revision_usage # +#################### +class drawing_sheet_revision_usage(area_in_set): + '''Entity drawing_sheet_revision_usage definition. + + :param sheet_number + :type sheet_number:identifier + ''' + def __init__( self , inherited0__area , inherited1__in_set , sheet_number, ): + area_in_set.__init__(self , inherited0__area , inherited1__in_set , ) + self.sheet_number = sheet_number + + @apply + def sheet_number(): + def fget( self ): + return self._sheet_number + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sheet_number is mantatory and can not be set to None') + if not check_type(value,identifier): + self._sheet_number = identifier(value) + else: + self._sheet_number = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.DRAWING_SHEET_REVISION' == TYPEOF(self.self.area_in_set.self.area)) and ('AUTOMOTIVE_DESIGN.DRAWING_REVISION' == TYPEOF(self.self.area_in_set.self.in_set))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY kinematic_property_representation_relation # +#################### +class kinematic_property_representation_relation(property_definition_representation): + '''Entity kinematic_property_representation_relation definition. + ''' + def __init__( self , inherited0__definition , inherited1__used_representation , ): + property_definition_representation.__init__(self , inherited0__definition , inherited1__used_representation , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.KINEMATIC_PROPERTY_DEFINITION' == TYPEOF(self.self.property_definition_representation.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('AUTOMOTIVE_DESIGN.KINEMATIC_GROUND_REPRESENTATION' == TYPEOF(self.self.property_definition_representation.self.used_representation)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY parametric_representation_context # +#################### +class parametric_representation_context(representation_context): + '''Entity parametric_representation_context definition. + ''' + def __init__( self , inherited0__context_identifier , inherited1__context_type , ): + representation_context.__init__(self , inherited0__context_identifier , inherited1__context_type , ) + +#################### + # ENTITY limits_and_fits # +#################### +class limits_and_fits(BaseEntityClass): + '''Entity limits_and_fits definition. + + :param form_variance + :type form_variance:label + + :param zone_variance + :type zone_variance:label + + :param grade + :type grade:label + + :param source + :type source:text + ''' + def __init__( self , form_variance,zone_variance,grade,source, ): + self.form_variance = form_variance + self.zone_variance = zone_variance + self.grade = grade + self.source = source + + @apply + def form_variance(): + def fget( self ): + return self._form_variance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument form_variance is mantatory and can not be set to None') + if not check_type(value,label): + self._form_variance = label(value) + else: + self._form_variance = value + return property(**locals()) + + @apply + def zone_variance(): + def fget( self ): + return self._zone_variance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument zone_variance is mantatory and can not be set to None') + if not check_type(value,label): + self._zone_variance = label(value) + else: + self._zone_variance = value + return property(**locals()) + + @apply + def grade(): + def fget( self ): + return self._grade + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument grade is mantatory and can not be set to None') + if not check_type(value,label): + self._grade = label(value) + else: + self._grade = value + return property(**locals()) + + @apply + def source(): + def fget( self ): + return self._source + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument source is mantatory and can not be set to None') + if not check_type(value,text): + self._source = text(value) + else: + self._source = value + return property(**locals()) + +#################### + # ENTITY prismatic_pair_range # +#################### +class prismatic_pair_range(simple_pair_range): + '''Entity prismatic_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:prismatic_pair + + :param lower_limit_actual_translation + :type lower_limit_actual_translation:translational_range_measure + + :param upper_limit_actual_translation + :type upper_limit_actual_translation:translational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,lower_limit_actual_translation,upper_limit_actual_translation, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.lower_limit_actual_translation = lower_limit_actual_translation + self.upper_limit_actual_translation = upper_limit_actual_translation + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,prismatic_pair): + self._simple_pair_range_applies_to_pair = prismatic_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def lower_limit_actual_translation(): + def fget( self ): + return self._lower_limit_actual_translation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_translation is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._lower_limit_actual_translation = translational_range_measure(value) + else: + self._lower_limit_actual_translation = value + return property(**locals()) + + @apply + def upper_limit_actual_translation(): + def fget( self ): + return self._upper_limit_actual_translation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_translation is mantatory and can not be set to None') + if not check_type(value,translational_range_measure): + self._upper_limit_actual_translation = translational_range_measure(value) + else: + self._upper_limit_actual_translation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_translation)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_translation))) XOR (self.lower_limit_actual_translation < self.upper_limit_actual_translation)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY product_concept_context # +#################### +class product_concept_context(application_context_element): + '''Entity product_concept_context definition. + + :param market_segment_type + :type market_segment_type:label + ''' + def __init__( self , inherited0__name , inherited1__frame_of_reference , market_segment_type, ): + application_context_element.__init__(self , inherited0__name , inherited1__frame_of_reference , ) + self.market_segment_type = market_segment_type + + @apply + def market_segment_type(): + def fget( self ): + return self._market_segment_type + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument market_segment_type is mantatory and can not be set to None') + if not check_type(value,label): + self._market_segment_type = label(value) + else: + self._market_segment_type = value + return property(**locals()) + +#################### + # ENTITY text_literal_with_extent # +#################### +class text_literal_with_extent(text_literal): + '''Entity text_literal_with_extent definition. + + :param extent + :type extent:planar_extent + ''' + def __init__( self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , extent, ): + text_literal.__init__(self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , ) + self.extent = extent + + @apply + def extent(): + def fget( self ): + return self._extent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extent is mantatory and can not be set to None') + if not check_type(value,planar_extent): + self._extent = planar_extent(value) + else: + self._extent = value + return property(**locals()) + +#################### + # ENTITY binary_function_call # +#################### +class binary_function_call(binary_numeric_expression): + '''Entity binary_function_call definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + binary_numeric_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY cartesian_transformation_operator_2d # +#################### +class cartesian_transformation_operator_2d(cartesian_transformation_operator): + '''Entity cartesian_transformation_operator_2d definition. + + :param u + :type u:LIST(2,2,'direction', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__name , inherited2__description , inherited3__axis1 , inherited4__axis2 , inherited5__local_origin , inherited6__scale , ): + cartesian_transformation_operator.__init__(self , inherited0__name , inherited1__name , inherited2__description , inherited3__axis1 , inherited4__axis2 , inherited5__local_origin , inherited6__scale , ) + + @apply + def u(): + def fget( self ): + attribute_eval = base_axis(2,self.self.cartesian_transformation_operator.self.axis1,self.self.cartesian_transformation_operator.self.axis2, None ) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument u is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.geometric_representation_item.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_action_assignment # +#################### +class applied_action_assignment(action_assignment): + '''Entity applied_action_assignment definition. + + :param items + :type items:SET(1,None,'action_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_action , items, ): + action_assignment.__init__(self , inherited0__assigned_action , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'action_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY pre_defined_presentation_style # +#################### +class pre_defined_presentation_style(founded_item,pre_defined_item): + '''Entity pre_defined_presentation_style definition. + ''' + def __init__( self , inherited0__name , ): + founded_item.__init__(self , ) + pre_defined_item.__init__(self , inherited0__name , ) + +#################### + # ENTITY process_plan # +#################### +class process_plan(action): + '''Entity process_plan definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__chosen_method , ): + action.__init__(self , inherited0__name , inherited1__description , inherited2__chosen_method , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ACTION_RELATIONSHIP.RELATING_ACTION'))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY surface_patch # +#################### +class surface_patch(founded_item): + '''Entity surface_patch definition. + + :param parent_surface + :type parent_surface:bounded_surface + + :param u_transition + :type u_transition:transition_code + + :param v_transition + :type v_transition:transition_code + + :param u_sense + :type u_sense:BOOLEAN + + :param v_sense + :type v_sense:BOOLEAN + + :param using_surfaces + :type using_surfaces:BAG(1,None,'rectangular_composite_surface', scope = schema_scope) + ''' + def __init__( self , parent_surface,u_transition,v_transition,u_sense,v_sense, ): + founded_item.__init__(self , ) + self.parent_surface = parent_surface + self.u_transition = u_transition + self.v_transition = v_transition + self.u_sense = u_sense + self.v_sense = v_sense + + @apply + def parent_surface(): + def fget( self ): + return self._parent_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parent_surface is mantatory and can not be set to None') + if not check_type(value,bounded_surface): + self._parent_surface = bounded_surface(value) + else: + self._parent_surface = value + return property(**locals()) + + @apply + def u_transition(): + def fget( self ): + return self._u_transition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u_transition is mantatory and can not be set to None') + if not check_type(value,transition_code): + self._u_transition = transition_code(value) + else: + self._u_transition = value + return property(**locals()) + + @apply + def v_transition(): + def fget( self ): + return self._v_transition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v_transition is mantatory and can not be set to None') + if not check_type(value,transition_code): + self._v_transition = transition_code(value) + else: + self._v_transition = value + return property(**locals()) + + @apply + def u_sense(): + def fget( self ): + return self._u_sense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u_sense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._u_sense = BOOLEAN(value) + else: + self._u_sense = value + return property(**locals()) + + @apply + def v_sense(): + def fget( self ): + return self._v_sense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v_sense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._v_sense = BOOLEAN(value) + else: + self._v_sense = value + return property(**locals()) + + @apply + def using_surfaces(): + def fget( self ): + return self._using_surfaces + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument using_surfaces is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('AUTOMOTIVE_DESIGN.CURVE_BOUNDED_SURFACE' == TYPEOF(self.parent_surface))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY unconstrained_pair_value # +#################### +class unconstrained_pair_value(pair_value): + '''Entity unconstrained_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:unconstrained_pair + + :param actual_placement + :type actual_placement:axis2_placement_3d + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_placement, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_placement = actual_placement + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,unconstrained_pair): + self._pair_value_applies_to_pair = unconstrained_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_placement(): + def fget( self ): + return self._actual_placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_placement is mantatory and can not be set to None') + if not check_type(value,axis2_placement_3d): + self._actual_placement = axis2_placement_3d(value) + else: + self._actual_placement = value + return property(**locals()) + +#################### + # ENTITY security_classification_assignment # +#################### +class security_classification_assignment(BaseEntityClass): + '''Entity security_classification_assignment definition. + + :param assigned_security_classification + :type assigned_security_classification:security_classification + + :param role + :type role:object_role + ''' + def __init__( self , assigned_security_classification, ): + self.assigned_security_classification = assigned_security_classification + + @apply + def assigned_security_classification(): + def fget( self ): + return self._assigned_security_classification + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigned_security_classification is mantatory and can not be set to None') + if not check_type(value,security_classification): + self._assigned_security_classification = security_classification(value) + else: + self._assigned_security_classification = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + attribute_eval = get_role(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument role is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_security_classification_assignment # +#################### +class applied_security_classification_assignment(security_classification_assignment): + '''Entity applied_security_classification_assignment definition. + + :param items + :type items:SET(1,None,'security_classification_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_security_classification , items, ): + security_classification_assignment.__init__(self , inherited0__assigned_security_classification , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'security_classification_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY log2_function # +#################### +class log2_function(unary_function_call): + '''Entity log2_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY product_definition_occurrence_relationship # +#################### +class product_definition_occurrence_relationship(BaseEntityClass): + '''Entity product_definition_occurrence_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param occurrence + :type occurrence:product_definition + + :param occurrence_usage + :type occurrence_usage:assembly_component_usage + ''' + def __init__( self , name,description,occurrence,occurrence_usage, ): + self.name = name + self.description = description + self.occurrence = occurrence + self.occurrence_usage = occurrence_usage + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def occurrence(): + def fget( self ): + return self._occurrence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument occurrence is mantatory and can not be set to None') + if not check_type(value,product_definition): + self._occurrence = product_definition(value) + else: + self._occurrence = value + return property(**locals()) + + @apply + def occurrence_usage(): + def fget( self ): + return self._occurrence_usage + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument occurrence_usage is mantatory and can not be set to None') + if not check_type(value,assembly_component_usage): + self._occurrence_usage = assembly_component_usage(value) + else: + self._occurrence_usage = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.occurrence_usage.self.relating_product_definition != self.occurrence) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.occurrence_usage.self.related_product_definition != self.occurrence) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.occurrence.self.formation == self.occurrence_usage.self.related_product_definition.self.formation) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY concentricity_tolerance # +#################### +class concentricity_tolerance(geometric_tolerance_with_datum_reference): + '''Entity concentricity_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ): + geometric_tolerance_with_datum_reference.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY approximation_tolerance # +#################### +class approximation_tolerance(founded_item): + '''Entity approximation_tolerance definition. + + :param tolerance + :type tolerance:tolerance_select + ''' + def __init__( self , tolerance, ): + founded_item.__init__(self , ) + self.tolerance = tolerance + + @apply + def tolerance(): + def fget( self ): + return self._tolerance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tolerance is mantatory and can not be set to None') + if not check_type(value,tolerance_select): + self._tolerance = tolerance_select(value) + else: + self._tolerance = value + return property(**locals()) + +#################### + # ENTITY length_unit # +#################### +class length_unit(named_unit): + '''Entity length_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 1) and (self.self.named_unit.self.dimensions.self.mass_exponent == 0)) and (self.self.named_unit.self.dimensions.self.time_exponent == 0)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 0)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 0)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 0)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY volume_measure_with_unit # +#################### +class volume_measure_with_unit(measure_with_unit): + '''Entity volume_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.VOLUME_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY dimension_related_tolerance_zone_element # +#################### +class dimension_related_tolerance_zone_element(BaseEntityClass): + '''Entity dimension_related_tolerance_zone_element definition. + + :param related_dimension + :type related_dimension:dimensional_location + + :param related_element + :type related_element:tolerance_zone_definition + ''' + def __init__( self , related_dimension,related_element, ): + self.related_dimension = related_dimension + self.related_element = related_element + + @apply + def related_dimension(): + def fget( self ): + return self._related_dimension + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_dimension is mantatory and can not be set to None') + if not check_type(value,dimensional_location): + self._related_dimension = dimensional_location(value) + else: + self._related_dimension = value + return property(**locals()) + + @apply + def related_element(): + def fget( self ): + return self._related_element + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_element is mantatory and can not be set to None') + if not check_type(value,tolerance_zone_definition): + self._related_element = tolerance_zone_definition(value) + else: + self._related_element = value + return property(**locals()) + +#################### + # ENTITY externally_defined_class # +#################### +class externally_defined_class(class_,externally_defined_item): + '''Entity externally_defined_class definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__item_id , inherited3__source , ): + class.__init__(self , inherited0__name , inherited1__description , ) + externally_defined_item.__init__(self , inherited2__item_id , inherited3__source , ) + +#################### + # ENTITY surface_style_control_grid # +#################### +class surface_style_control_grid(founded_item): + '''Entity surface_style_control_grid definition. + + :param style_of_control_grid + :type style_of_control_grid:curve_or_render + ''' + def __init__( self , style_of_control_grid, ): + founded_item.__init__(self , ) + self.style_of_control_grid = style_of_control_grid + + @apply + def style_of_control_grid(): + def fget( self ): + return self._style_of_control_grid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument style_of_control_grid is mantatory and can not be set to None') + if not check_type(value,curve_or_render): + self._style_of_control_grid = curve_or_render(value) + else: + self._style_of_control_grid = value + return property(**locals()) + +#################### + # ENTITY advanced_face # +#################### +class advanced_face(face_surface): + '''Entity advanced_face definition. + ''' + def __init__( self , inherited0__name , inherited1__bounds , inherited2__name , inherited3__face_geometry , inherited4__same_sense , ): + face_surface.__init__(self , inherited0__name , inherited1__bounds , inherited2__name , inherited3__face_geometry , inherited4__same_sense , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.ELEMENTARY_SURFACE','AUTOMOTIVE_DESIGN.B_SPLINE_SURFACE','AUTOMOTIVE_DESIGN.SWEPT_SURFACE'] * TYPEOF(self.face_geometry)) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (( not ('AUTOMOTIVE_DESIGN.SWEPT_SURFACE' == TYPEOF(self.face_geometry))) or (SIZEOF(['AUTOMOTIVE_DESIGN.LINE','AUTOMOTIVE_DESIGN.CONIC','AUTOMOTIVE_DESIGN.POLYLINE','AUTOMOTIVE_DESIGN.B_SPLINE_CURVE'] * TYPEOF(self.face_geometry.self.swept_surface.self.swept_curve)) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 0) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 0) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (((( not ('AUTOMOTIVE_DESIGN.SWEPT_SURFACE' == TYPEOF(self.face_geometry))) or ( not ('AUTOMOTIVE_DESIGN.POLYLINE' == TYPEOF(self.face_geometry.self.swept_surface.self.swept_curve)))) or (SIZEOF(self.face_geometry.self.swept_surface.self.swept_curve.self.polyline.self.points) >= 3)) and (SIZEOF(None) == 0)) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + +#################### + # ENTITY measure_representation_item # +#################### +class measure_representation_item(representation_item,measure_with_unit): + '''Entity measure_representation_item definition. + ''' + def __init__( self , inherited0__name , inherited1__value_component , inherited2__unit_component , ): + representation_item.__init__(self , inherited0__name , ) + measure_with_unit.__init__(self , inherited1__value_component , inherited2__unit_component , ) + +#################### + # ENTITY object_role # +#################### +class object_role(BaseEntityClass): + '''Entity object_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY right_circular_cone # +#################### +class right_circular_cone(geometric_representation_item): + '''Entity right_circular_cone definition. + + :param position + :type position:axis1_placement + + :param height + :type height:positive_length_measure + + :param radius + :type radius:length_measure + + :param semi_angle + :type semi_angle:plane_angle_measure + ''' + def __init__( self , inherited0__name , position,height,radius,semi_angle, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.position = position + self.height = height + self.radius = radius + self.semi_angle = semi_angle + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,axis1_placement): + self._position = axis1_placement(value) + else: + self._position = value + return property(**locals()) + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._height = positive_length_measure(value) + else: + self._height = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._radius = length_measure(value) + else: + self._radius = value + return property(**locals()) + + @apply + def semi_angle(): + def fget( self ): + return self._semi_angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semi_angle is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._semi_angle = plane_angle_measure(value) + else: + self._semi_angle = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.radius >= 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY rolling_curve_pair_value # +#################### +class rolling_curve_pair_value(pair_value): + '''Entity rolling_curve_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:rolling_curve_pair + + :param actual_point_on_curve_1 + :type actual_point_on_curve_1:point_on_curve + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_point_on_curve_1, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_point_on_curve_1 = actual_point_on_curve_1 + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,rolling_curve_pair): + self._pair_value_applies_to_pair = rolling_curve_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_point_on_curve_1(): + def fget( self ): + return self._actual_point_on_curve_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_point_on_curve_1 is mantatory and can not be set to None') + if not check_type(value,point_on_curve): + self._actual_point_on_curve_1 = point_on_curve(value) + else: + self._actual_point_on_curve_1 = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.pair_value.self.applies_to_pair.self.planar_curve_pair.self.curve_1 == self.actual_point_on_curve_1.self.basis_curve) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY security_classification_level # +#################### +class security_classification_level(BaseEntityClass): + '''Entity security_classification_level definition. + + :param name + :type name:label + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY symbol_target # +#################### +class symbol_target(geometric_representation_item): + '''Entity symbol_target definition. + + :param placement + :type placement:axis2_placement + + :param x_scale + :type x_scale:positive_ratio_measure + + :param y_scale + :type y_scale:positive_ratio_measure + ''' + def __init__( self , inherited0__name , placement,x_scale,y_scale, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.placement = placement + self.x_scale = x_scale + self.y_scale = y_scale + + @apply + def placement(): + def fget( self ): + return self._placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placement is mantatory and can not be set to None') + if not check_type(value,axis2_placement): + self._placement = axis2_placement(value) + else: + self._placement = value + return property(**locals()) + + @apply + def x_scale(): + def fget( self ): + return self._x_scale + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument x_scale is mantatory and can not be set to None') + if not check_type(value,positive_ratio_measure): + self._x_scale = positive_ratio_measure(value) + else: + self._x_scale = value + return property(**locals()) + + @apply + def y_scale(): + def fget( self ): + return self._y_scale + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument y_scale is mantatory and can not be set to None') + if not check_type(value,positive_ratio_measure): + self._y_scale = positive_ratio_measure(value) + else: + self._y_scale = value + return property(**locals()) + +#################### + # ENTITY thermodynamic_temperature_measure_with_unit # +#################### +class thermodynamic_temperature_measure_with_unit(measure_with_unit): + '''Entity thermodynamic_temperature_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.THERMODYNAMIC_TEMPERATURE_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_document_usage_constraint_assignment # +#################### +class applied_document_usage_constraint_assignment(document_usage_constraint_assignment): + '''Entity applied_document_usage_constraint_assignment definition. + + :param items + :type items:SET(1,None,'document_reference_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_document_usage , inherited1__role , items, ): + document_usage_constraint_assignment.__init__(self , inherited0__assigned_document_usage , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'document_reference_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + +#################### + # ENTITY approval_relationship # +#################### +class approval_relationship(BaseEntityClass): + '''Entity approval_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_approval + :type relating_approval:approval + + :param related_approval + :type related_approval:approval + ''' + def __init__( self , name,description,relating_approval,related_approval, ): + self.name = name + self.description = description + self.relating_approval = relating_approval + self.related_approval = related_approval + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_approval(): + def fget( self ): + return self._relating_approval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_approval is mantatory and can not be set to None') + if not check_type(value,approval): + self._relating_approval = approval(value) + else: + self._relating_approval = value + return property(**locals()) + + @apply + def related_approval(): + def fget( self ): + return self._related_approval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_approval is mantatory and can not be set to None') + if not check_type(value,approval): + self._related_approval = approval(value) + else: + self._related_approval = value + return property(**locals()) + +#################### + # ENTITY atan_function # +#################### +class atan_function(binary_function_call): + '''Entity atan_function definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + binary_function_call.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY kinematic_link_representation_relation # +#################### +class kinematic_link_representation_relation(BaseEntityClass): + '''Entity kinematic_link_representation_relation definition. + + :param topological_aspects + :type topological_aspects:kinematic_link + + :param geometric_aspects + :type geometric_aspects:kinematic_link_representation + ''' + def __init__( self , topological_aspects,geometric_aspects, ): + self.topological_aspects = topological_aspects + self.geometric_aspects = geometric_aspects + + @apply + def topological_aspects(): + def fget( self ): + return self._topological_aspects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument topological_aspects is mantatory and can not be set to None') + if not check_type(value,kinematic_link): + self._topological_aspects = kinematic_link(value) + else: + self._topological_aspects = value + return property(**locals()) + + @apply + def geometric_aspects(): + def fget( self ): + return self._geometric_aspects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument geometric_aspects is mantatory and can not be set to None') + if not check_type(value,kinematic_link_representation): + self._geometric_aspects = kinematic_link_representation(value) + else: + self._geometric_aspects = value + return property(**locals()) + +#################### + # ENTITY pocket # +#################### +class pocket(feature_definition): + '''Entity pocket definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (self.self.description == ['open rectangular','closed rectangular','complex']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((self.self.description != 'complex') or (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((self.self.description != 'closed rectangular') or (SIZEOF(None) == 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.description != 'open rectangular') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) <= 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 0) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 0) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) <= 1) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + +#################### + # ENTITY moments_of_inertia_representation # +#################### +class moments_of_inertia_representation(representation): + '''Entity moments_of_inertia_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = ((SIZEOF(self.self.items) == 1) and (SIZEOF(None) == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY polyline # +#################### +class polyline(bounded_curve): + '''Entity polyline definition. + + :param points + :type points:LIST(2,None,'cartesian_point', scope = schema_scope) + ''' + def __init__( self , inherited0__name , points, ): + bounded_curve.__init__(self , inherited0__name , ) + self.points = points + + @apply + def points(): + def fget( self ): + return self._points + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument points is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'cartesian_point', scope = schema_scope)): + self._points = LIST(value) + else: + self._points = value + return property(**locals()) + +#################### + # ENTITY approval_person_organization # +#################### +class approval_person_organization(BaseEntityClass): + '''Entity approval_person_organization definition. + + :param person_organization + :type person_organization:person_organization_select + + :param authorized_approval + :type authorized_approval:approval + + :param role + :type role:approval_role + ''' + def __init__( self , person_organization,authorized_approval,role, ): + self.person_organization = person_organization + self.authorized_approval = authorized_approval + self.role = role + + @apply + def person_organization(): + def fget( self ): + return self._person_organization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument person_organization is mantatory and can not be set to None') + if not check_type(value,person_organization_select): + self._person_organization = person_organization_select(value) + else: + self._person_organization = value + return property(**locals()) + + @apply + def authorized_approval(): + def fget( self ): + return self._authorized_approval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument authorized_approval is mantatory and can not be set to None') + if not check_type(value,approval): + self._authorized_approval = approval(value) + else: + self._authorized_approval = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,approval_role): + self._role = approval_role(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY chamfer # +#################### +class chamfer(transition_feature): + '''Entity chamfer definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + transition_feature.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY div_expression # +#################### +class div_expression(binary_numeric_expression): + '''Entity div_expression definition. + ''' + def __init__( self , inherited0__operands , inherited1__binary_generic_expression_operands , ): + binary_numeric_expression.__init__(self , inherited0__operands , inherited1__binary_generic_expression_operands , ) + +#################### + # ENTITY document_representation_type # +#################### +class document_representation_type(BaseEntityClass): + '''Entity document_representation_type definition. + + :param name + :type name:label + + :param represented_document + :type represented_document:document + ''' + def __init__( self , name,represented_document, ): + self.name = name + self.represented_document = represented_document + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def represented_document(): + def fget( self ): + return self._represented_document + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument represented_document is mantatory and can not be set to None') + if not check_type(value,document): + self._represented_document = document(value) + else: + self._represented_document = value + return property(**locals()) + +#################### + # ENTITY kinematic_link_representation_association # +#################### +class kinematic_link_representation_association(representation_relationship): + '''Entity kinematic_link_representation_association definition. + + :param representation_relationship_rep_1 + :type representation_relationship_rep_1:kinematic_link_representation + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , representation_relationship_rep_1, ): + representation_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , ) + self.representation_relationship_rep_1 = representation_relationship_rep_1 + + @apply + def representation_relationship_rep_1(): + def fget( self ): + return self._representation_relationship_rep_1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation_relationship_rep_1 is mantatory and can not be set to None') + if not check_type(value,kinematic_link_representation): + self._representation_relationship_rep_1 = kinematic_link_representation(value) + else: + self._representation_relationship_rep_1 = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.representation_relationship.self.rep_2.self.context_of_items == self.self.representation_relationship.self.rep_1.self.representation.self.context_of_items) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.KINEMATIC_GROUND_REPRESENTATION','AUTOMOTIVE_DESIGN.KINEMATIC_LINK_REPRESENTATION'] * TYPEOF(self.self.representation_relationship.self.rep_2)) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY surface_style_silhouette # +#################### +class surface_style_silhouette(founded_item): + '''Entity surface_style_silhouette definition. + + :param style_of_silhouette + :type style_of_silhouette:curve_or_render + ''' + def __init__( self , style_of_silhouette, ): + founded_item.__init__(self , ) + self.style_of_silhouette = style_of_silhouette + + @apply + def style_of_silhouette(): + def fget( self ): + return self._style_of_silhouette + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument style_of_silhouette is mantatory and can not be set to None') + if not check_type(value,curve_or_render): + self._style_of_silhouette = curve_or_render(value) + else: + self._style_of_silhouette = value + return property(**locals()) + +#################### + # ENTITY revolute_pair_range # +#################### +class revolute_pair_range(simple_pair_range): + '''Entity revolute_pair_range definition. + + :param simple_pair_range_applies_to_pair + :type simple_pair_range_applies_to_pair:revolute_pair + + :param lower_limit_actual_rotation + :type lower_limit_actual_rotation:rotational_range_measure + + :param upper_limit_actual_rotation + :type upper_limit_actual_rotation:rotational_range_measure + ''' + def __init__( self , inherited0__applies_to_pair , simple_pair_range_applies_to_pair,lower_limit_actual_rotation,upper_limit_actual_rotation, ): + simple_pair_range.__init__(self , inherited0__applies_to_pair , ) + self.simple_pair_range_applies_to_pair = simple_pair_range_applies_to_pair + self.lower_limit_actual_rotation = lower_limit_actual_rotation + self.upper_limit_actual_rotation = upper_limit_actual_rotation + + @apply + def simple_pair_range_applies_to_pair(): + def fget( self ): + return self._simple_pair_range_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument simple_pair_range_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,revolute_pair): + self._simple_pair_range_applies_to_pair = revolute_pair(value) + else: + self._simple_pair_range_applies_to_pair = value + return property(**locals()) + + @apply + def lower_limit_actual_rotation(): + def fget( self ): + return self._lower_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lower_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._lower_limit_actual_rotation = rotational_range_measure(value) + else: + self._lower_limit_actual_rotation = value + return property(**locals()) + + @apply + def upper_limit_actual_rotation(): + def fget( self ): + return self._upper_limit_actual_rotation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument upper_limit_actual_rotation is mantatory and can not be set to None') + if not check_type(value,rotational_range_measure): + self._upper_limit_actual_rotation = rotational_range_measure(value) + else: + self._upper_limit_actual_rotation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.lower_limit_actual_rotation)) or ('AUTOMOTIVE_DESIGN.UNLIMITED_RANGE' == TYPEOF(self.upper_limit_actual_rotation))) XOR (self.lower_limit_actual_rotation < self.upper_limit_actual_rotation)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY structured_dimension_callout # +#################### +class structured_dimension_callout(draughting_callout): + '''Entity structured_dimension_callout definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + draughting_callout.__init__(self , inherited0__name , inherited1__contents , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(TYPEOF(self) * ['AUTOMOTIVE_DESIGN.DATUM_FEATURE_CALLOUT','AUTOMOTIVE_DESIGN.DATUM_TARGET_CALLOUT','AUTOMOTIVE_DESIGN.GEOMETRICAL_TOLERANCE_CALLOUT','AUTOMOTIVE_DESIGN.LEADER_DIRECTED_CALLOUT','AUTOMOTIVE_DESIGN.PROJECTION_DIRECTED_CALLOUT','AUTOMOTIVE_DESIGN.DIMENSION_CURVE_DIRECTED_CALLOUT']) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) >= 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) <= 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) <= 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (( not (SIZEOF(None) > 0)) or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (( not (SIZEOF(None) > 0)) or (SIZEOF(None) == 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY time_interval_based_effectivity # +#################### +class time_interval_based_effectivity(effectivity): + '''Entity time_interval_based_effectivity definition. + + :param effectivity_period + :type effectivity_period:time_interval + ''' + def __init__( self , inherited0__id , effectivity_period, ): + effectivity.__init__(self , inherited0__id , ) + self.effectivity_period = effectivity_period + + @apply + def effectivity_period(): + def fget( self ): + return self._effectivity_period + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument effectivity_period is mantatory and can not be set to None') + if not check_type(value,time_interval): + self._effectivity_period = time_interval(value) + else: + self._effectivity_period = value + return property(**locals()) + +#################### + # ENTITY dimensional_size_with_path # +#################### +class dimensional_size_with_path(dimensional_size): + '''Entity dimensional_size_with_path definition. + + :param path + :type path:shape_aspect + ''' + def __init__( self , inherited0__applies_to , inherited1__name , path, ): + dimensional_size.__init__(self , inherited0__applies_to , inherited1__name , ) + self.path = path + + @apply + def path(): + def fget( self ): + return self._path + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument path is mantatory and can not be set to None') + if not check_type(value,shape_aspect): + self._path = shape_aspect(value) + else: + self._path = value + return property(**locals()) + +#################### + # ENTITY two_direction_repeat_factor # +#################### +class two_direction_repeat_factor(one_direction_repeat_factor): + '''Entity two_direction_repeat_factor definition. + + :param second_repeat_factor + :type second_repeat_factor:vector + ''' + def __init__( self , inherited0__name , inherited1__repeat_factor , second_repeat_factor, ): + one_direction_repeat_factor.__init__(self , inherited0__name , inherited1__repeat_factor , ) + self.second_repeat_factor = second_repeat_factor + + @apply + def second_repeat_factor(): + def fget( self ): + return self._second_repeat_factor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument second_repeat_factor is mantatory and can not be set to None') + if not check_type(value,vector): + self._second_repeat_factor = vector(value) + else: + self._second_repeat_factor = value + return property(**locals()) + +#################### + # ENTITY retention # +#################### +class retention(action): + '''Entity retention definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__chosen_method , ): + action.__init__(self , inherited0__name , inherited1__description , inherited2__chosen_method , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) >= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (((SIZEOF(None) == 1) and (SIZEOF(None) == 1)) and (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ACTION_RELATIONSHIP.RELATING_ACTION')) + SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.ACTION_RELATIONSHIP.RELATED_ACTION'))) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY revolved_face_solid # +#################### +class revolved_face_solid(swept_face_solid): + '''Entity revolved_face_solid definition. + + :param axis + :type axis:axis1_placement + + :param angle + :type angle:plane_angle_measure + + :param axis_line + :type axis_line:line + ''' + def __init__( self , inherited0__name , inherited1__swept_face , axis,angle, ): + swept_face_solid.__init__(self , inherited0__name , inherited1__swept_face , ) + self.axis = axis + self.angle = angle + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axis is mantatory and can not be set to None') + if not check_type(value,axis1_placement): + self._axis = axis1_placement(value) + else: + self._axis = value + return property(**locals()) + + @apply + def angle(): + def fget( self ): + return self._angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument angle is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._angle = plane_angle_measure(value) + else: + self._angle = value + return property(**locals()) + + @apply + def axis_line(): + def fget( self ): + attribute_eval = (((representation_item('') == geometric_representation_item()) == curve()) == line(self.axis.self.location,(representation_item('') == geometric_representation_item()) == vector(self.axis.self.z,1))) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument axis_line is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY invisibility # +#################### +class invisibility(BaseEntityClass): + '''Entity invisibility definition. + + :param invisible_items + :type invisible_items:SET(1,None,'invisible_item', scope = schema_scope) + ''' + def __init__( self , invisible_items, ): + self.invisible_items = invisible_items + + @apply + def invisible_items(): + def fget( self ): + return self._invisible_items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument invisible_items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'invisible_item', scope = schema_scope)): + self._invisible_items = SET(value) + else: + self._invisible_items = value + return property(**locals()) + +#################### + # ENTITY surface_replica # +#################### +class surface_replica(surface): + '''Entity surface_replica definition. + + :param parent_surface + :type parent_surface:surface + + :param transformation + :type transformation:cartesian_transformation_operator_3d + ''' + def __init__( self , inherited0__name , parent_surface,transformation, ): + surface.__init__(self , inherited0__name , ) + self.parent_surface = parent_surface + self.transformation = transformation + + @apply + def parent_surface(): + def fget( self ): + return self._parent_surface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parent_surface is mantatory and can not be set to None') + if not check_type(value,surface): + self._parent_surface = surface(value) + else: + self._parent_surface = value + return property(**locals()) + + @apply + def transformation(): + def fget( self ): + return self._transformation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transformation is mantatory and can not be set to None') + if not check_type(value,cartesian_transformation_operator_3d): + self._transformation = cartesian_transformation_operator_3d(value) + else: + self._transformation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = acyclic_surface_replica(self,self.parent_surface) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY text_style_with_mirror # +#################### +class text_style_with_mirror(text_style): + '''Entity text_style_with_mirror definition. + + :param mirror_placement + :type mirror_placement:axis2_placement + ''' + def __init__( self , inherited0__name , inherited1__character_appearance , mirror_placement, ): + text_style.__init__(self , inherited0__name , inherited1__character_appearance , ) + self.mirror_placement = mirror_placement + + @apply + def mirror_placement(): + def fget( self ): + return self._mirror_placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mirror_placement is mantatory and can not be set to None') + if not check_type(value,axis2_placement): + self._mirror_placement = axis2_placement(value) + else: + self._mirror_placement = value + return property(**locals()) + +#################### + # ENTITY context_dependent_invisibility # +#################### +class context_dependent_invisibility(invisibility): + '''Entity context_dependent_invisibility definition. + + :param presentation_context + :type presentation_context:invisibility_context + ''' + def __init__( self , inherited0__invisible_items , presentation_context, ): + invisibility.__init__(self , inherited0__invisible_items , ) + self.presentation_context = presentation_context + + @apply + def presentation_context(): + def fget( self ): + return self._presentation_context + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument presentation_context is mantatory and can not be set to None') + if not check_type(value,invisibility_context): + self._presentation_context = invisibility_context(value) + else: + self._presentation_context = value + return property(**locals()) + +#################### + # ENTITY fillet # +#################### +class fillet(transition_feature): + '''Entity fillet definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + transition_feature.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = ((self.self.description != 'constant radius') XOR (SIZEOF(None) == 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 0)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((self.self.description != 'constant radius') or (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 1) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + +#################### + # ENTITY log10_function # +#################### +class log10_function(unary_function_call): + '''Entity log10_function definition. + ''' + def __init__( self , inherited0__operand , inherited1__unary_generic_expression_operand , ): + unary_function_call.__init__(self , inherited0__operand , inherited1__unary_generic_expression_operand , ) + +#################### + # ENTITY thread # +#################### +class thread(feature_definition): + '''Entity thread definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) <= 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) <= 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 1) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) == 1) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (SIZEOF(None) <= 1) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(None) == 0) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + +#################### + # ENTITY faceted_brep_shape_representation # +#################### +class faceted_brep_shape_representation(shape_representation): + '''Entity faceted_brep_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 0) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 0) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 0) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY document_usage_constraint # +#################### +class document_usage_constraint(BaseEntityClass): + '''Entity document_usage_constraint definition. + + :param source + :type source:document + + :param subject_element + :type subject_element:label + + :param subject_element_value + :type subject_element_value:text + ''' + def __init__( self , source,subject_element,subject_element_value, ): + self.source = source + self.subject_element = subject_element + self.subject_element_value = subject_element_value + + @apply + def source(): + def fget( self ): + return self._source + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument source is mantatory and can not be set to None') + if not check_type(value,document): + self._source = document(value) + else: + self._source = value + return property(**locals()) + + @apply + def subject_element(): + def fget( self ): + return self._subject_element + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument subject_element is mantatory and can not be set to None') + if not check_type(value,label): + self._subject_element = label(value) + else: + self._subject_element = value + return property(**locals()) + + @apply + def subject_element_value(): + def fget( self ): + return self._subject_element_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument subject_element_value is mantatory and can not be set to None') + if not check_type(value,text): + self._subject_element_value = text(value) + else: + self._subject_element_value = value + return property(**locals()) + +#################### + # ENTITY light_source_spot # +#################### +class light_source_spot(light_source): + '''Entity light_source_spot definition. + + :param position + :type position:cartesian_point + + :param orientation + :type orientation:direction + + :param concentration_exponent + :type concentration_exponent:REAL + + :param constant_attenuation + :type constant_attenuation:REAL + + :param distance_attenuation + :type distance_attenuation:REAL + + :param spread_angle + :type spread_angle:positive_plane_angle_measure + ''' + def __init__( self , inherited0__name , inherited1__light_colour , position,orientation,concentration_exponent,constant_attenuation,distance_attenuation,spread_angle, ): + light_source.__init__(self , inherited0__name , inherited1__light_colour , ) + self.position = position + self.orientation = orientation + self.concentration_exponent = concentration_exponent + self.constant_attenuation = constant_attenuation + self.distance_attenuation = distance_attenuation + self.spread_angle = spread_angle + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,cartesian_point): + self._position = cartesian_point(value) + else: + self._position = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,direction): + self._orientation = direction(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def concentration_exponent(): + def fget( self ): + return self._concentration_exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument concentration_exponent is mantatory and can not be set to None') + if not check_type(value,REAL): + self._concentration_exponent = REAL(value) + else: + self._concentration_exponent = value + return property(**locals()) + + @apply + def constant_attenuation(): + def fget( self ): + return self._constant_attenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constant_attenuation is mantatory and can not be set to None') + if not check_type(value,REAL): + self._constant_attenuation = REAL(value) + else: + self._constant_attenuation = value + return property(**locals()) + + @apply + def distance_attenuation(): + def fget( self ): + return self._distance_attenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distance_attenuation is mantatory and can not be set to None') + if not check_type(value,REAL): + self._distance_attenuation = REAL(value) + else: + self._distance_attenuation = value + return property(**locals()) + + @apply + def spread_angle(): + def fget( self ): + return self._spread_angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument spread_angle is mantatory and can not be set to None') + if not check_type(value,positive_plane_angle_measure): + self._spread_angle = positive_plane_angle_measure(value) + else: + self._spread_angle = value + return property(**locals()) + +#################### + # ENTITY presentation_style_by_context # +#################### +class presentation_style_by_context(presentation_style_assignment): + '''Entity presentation_style_by_context definition. + + :param style_context + :type style_context:style_context_select + ''' + def __init__( self , inherited0__styles , style_context, ): + presentation_style_assignment.__init__(self , inherited0__styles , ) + self.style_context = style_context + + @apply + def style_context(): + def fget( self ): + return self._style_context + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument style_context is mantatory and can not be set to None') + if not check_type(value,style_context_select): + self._style_context = style_context_select(value) + else: + self._style_context = value + return property(**locals()) + +#################### + # ENTITY shape_dimension_representation # +#################### +class shape_dimension_representation(shape_representation): + '''Entity shape_dimension_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(self.self.representation.self.items) <= 3) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY vertex_point # +#################### +class vertex_point(vertex,geometric_representation_item): + '''Entity vertex_point definition. + + :param vertex_geometry + :type vertex_geometry:point + ''' + def __init__( self , inherited0__name , inherited1__name , vertex_geometry, ): + vertex.__init__(self , inherited0__name , ) + geometric_representation_item.__init__(self , inherited1__name , ) + self.vertex_geometry = vertex_geometry + + @apply + def vertex_geometry(): + def fget( self ): + return self._vertex_geometry + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vertex_geometry is mantatory and can not be set to None') + if not check_type(value,point): + self._vertex_geometry = point(value) + else: + self._vertex_geometry = value + return property(**locals()) + +#################### + # ENTITY annotation_symbol # +#################### +class annotation_symbol(mapped_item): + '''Entity annotation_symbol definition. + + :param mapped_item_mapping_source + :type mapped_item_mapping_source:symbol_representation_map + + :param mapped_item_mapping_target + :type mapped_item_mapping_target:symbol_target + ''' + def __init__( self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , mapped_item_mapping_source,mapped_item_mapping_target, ): + mapped_item.__init__(self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , ) + self.mapped_item_mapping_source = mapped_item_mapping_source + self.mapped_item_mapping_target = mapped_item_mapping_target + + @apply + def mapped_item_mapping_source(): + def fget( self ): + return self._mapped_item_mapping_source + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapped_item_mapping_source is mantatory and can not be set to None') + if not check_type(value,symbol_representation_map): + self._mapped_item_mapping_source = symbol_representation_map(value) + else: + self._mapped_item_mapping_source = value + return property(**locals()) + + @apply + def mapped_item_mapping_target(): + def fget( self ): + return self._mapped_item_mapping_target + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mapped_item_mapping_target is mantatory and can not be set to None') + if not check_type(value,symbol_target): + self._mapped_item_mapping_target = symbol_target(value) + else: + self._mapped_item_mapping_target = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.GEOMETRIC_REPRESENTATION_ITEM' == TYPEOF(self)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY centre_of_symmetry # +#################### +class centre_of_symmetry(derived_shape_aspect): + '''Entity centre_of_symmetry definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + derived_shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY string_literal # +#################### +class string_literal(simple_string_expression,generic_literal): + '''Entity string_literal definition. + + :param the_value + :type the_value:STRING + ''' + def __init__( self , the_value, ): + simple_string_expression.__init__(self , ) + generic_literal.__init__(self , ) + self.the_value = the_value + + @apply + def the_value(): + def fget( self ): + return self._the_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument the_value is mantatory and can not be set to None') + if not check_type(value,STRING): + self._the_value = STRING(value) + else: + self._the_value = value + return property(**locals()) + +#################### + # ENTITY oriented_closed_shell # +#################### +class oriented_closed_shell(closed_shell): + '''Entity oriented_closed_shell definition. + + :param closed_shell_element + :type closed_shell_element:closed_shell + + :param orientation + :type orientation:BOOLEAN + + :param connected_face_set_cfs_faces + :type connected_face_set_cfs_faces:SET(1,None,'face', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__cfs_faces , closed_shell_element,orientation, ): + closed_shell.__init__(self , inherited0__name , inherited1__cfs_faces , ) + self.closed_shell_element = closed_shell_element + self.orientation = orientation + + @apply + def closed_shell_element(): + def fget( self ): + return self._closed_shell_element + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument closed_shell_element is mantatory and can not be set to None') + if not check_type(value,closed_shell): + self._closed_shell_element = closed_shell(value) + else: + self._closed_shell_element = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def connected_face_set_cfs_faces(): + def fget( self ): + attribute_eval = conditional_reverse(self.self.orientation,self.self.closed_shell_element.self.cfs_faces) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument connected_face_set_cfs_faces is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('AUTOMOTIVE_DESIGN.ORIENTED_CLOSED_SHELL' == TYPEOF(self.self.closed_shell_element))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY point_on_planar_curve_pair_value # +#################### +class point_on_planar_curve_pair_value(pair_value): + '''Entity point_on_planar_curve_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:point_on_planar_curve_pair + + :param actual_point_on_curve + :type actual_point_on_curve:point_on_curve + + :param input_orientation + :type input_orientation:spatial_rotation + + :param actual_orientation + :type actual_orientation:ARRAY(ypr_index(yaw),ypr_index(roll),'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,actual_point_on_curve,input_orientation, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.actual_point_on_curve = actual_point_on_curve + self.input_orientation = input_orientation + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,point_on_planar_curve_pair): + self._pair_value_applies_to_pair = point_on_planar_curve_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def actual_point_on_curve(): + def fget( self ): + return self._actual_point_on_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actual_point_on_curve is mantatory and can not be set to None') + if not check_type(value,point_on_curve): + self._actual_point_on_curve = point_on_curve(value) + else: + self._actual_point_on_curve = value + return property(**locals()) + + @apply + def input_orientation(): + def fget( self ): + return self._input_orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument input_orientation is mantatory and can not be set to None') + if not check_type(value,spatial_rotation): + self._input_orientation = spatial_rotation(value) + else: + self._input_orientation = value + return property(**locals()) + + @apply + def actual_orientation(): + def fget( self ): + attribute_eval = convert_spatial_to_ypr_rotation(self.self.pair_value.self.applies_to_pair,self.input_orientation) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument actual_orientation is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.pair_value.self.applies_to_pair.self.point_on_planar_curve_pair.self.pair_curve == self.actual_point_on_curve.self.basis_curve) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY rounded_u_profile # +#################### +class rounded_u_profile(shape_aspect): + '''Entity rounded_u_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY boss_top # +#################### +class boss_top(shape_aspect): + '''Entity boss_top definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.description == ['planar','complex']) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((self.self.description != 'planar') or (SIZEOF(None) == 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.self.description != 'planar') or (SIZEOF(None) == 1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((self.self.description != 'complex') or (SIZEOF(None) == 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) == 0)) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) <= 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + +#################### + # ENTITY constructive_geometry_representation_relationship # +#################### +class constructive_geometry_representation_relationship(representation_relationship): + '''Entity constructive_geometry_representation_relationship definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , ): + representation_relationship.__init__(self , inherited0__name , inherited1__description , inherited2__rep_1 , inherited3__rep_2 , ) + def wr1(self): + eval_wr1_wr = ((self.self.rep_1.self.context_of_items == self.self.rep_2.self.context_of_items) and (('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_REPRESENTATION_CONTEXT') == TYPEOF(self.self.rep_1.self.context_of_items))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (('AUTOMOTIVE_DESIGN.' + 'CONSTRUCTIVE_GEOMETRY_REPRESENTATION') == TYPEOF(self.self.rep_2)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(['AUTOMOTIVE_DESIGN.' + 'SHAPE_REPRESENTATION','AUTOMOTIVE_DESIGN.' + 'CONSTRUCTIVE_GEOMETRY_REPRESENTATION'] * TYPEOF(self.self.rep_1)) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ( not (('AUTOMOTIVE_DESIGN.' + 'REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION') == TYPEOF(self))) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY hardness_representation # +#################### +class hardness_representation(representation): + '''Entity hardness_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (((2 <= SIZEOF(self.self.items)) and (SIZEOF(self.self.items) <= 4)) and ((SIZEOF(None) + SIZEOF(None)) == SIZEOF(self.self.items))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) <= 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) <= 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.USED_REPRESENTATION')) == 1) and (SIZEOF(None) == 1)) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + +#################### + # ENTITY joggle # +#################### +class joggle(feature_definition): + '''Entity joggle definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) <= 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 1) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) <= 1) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (SIZEOF(None) <= 1) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(None) <= 1) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = (SIZEOF(None) <= 1) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + +#################### + # ENTITY person_and_organization # +#################### +class person_and_organization(BaseEntityClass): + '''Entity person_and_organization definition. + + :param the_person + :type the_person:person + + :param the_organization + :type the_organization:organization + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , the_person,the_organization, ): + self.the_person = the_person + self.the_organization = the_organization + + @apply + def the_person(): + def fget( self ): + return self._the_person + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument the_person is mantatory and can not be set to None') + if not check_type(value,person): + self._the_person = person(value) + else: + self._the_person = value + return property(**locals()) + + @apply + def the_organization(): + def fget( self ): + return self._the_organization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument the_organization is mantatory and can not be set to None') + if not check_type(value,organization): + self._the_organization = organization(value) + else: + self._the_organization = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + attribute_eval = get_name_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument name is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def description(): + def fget( self ): + attribute_eval = get_description_value(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument description is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.NAME_ATTRIBUTE.NAMED_ITEM')) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY curve_dimension # +#################### +class curve_dimension(dimension_curve_directed_callout): + '''Entity curve_dimension definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + dimension_curve_directed_callout.__init__(self , inherited0__name , inherited1__contents , ) + +#################### + # ENTITY inclusion_product_concept_feature # +#################### +class inclusion_product_concept_feature(conditional_concept_feature): + '''Entity inclusion_product_concept_feature definition. + ''' + def __init__( self , inherited0__id , inherited1__name , inherited2__description , inherited3__condition , ): + conditional_concept_feature.__init__(self , inherited0__id , inherited1__name , inherited2__description , inherited3__condition , ) + def wr1(self): + eval_wr1_wr = ( not (('AUTOMOTIVE_DESIGN.' + 'PACKAGE_PRODUCT_CONCEPT_FEATURE') == TYPEOF(self))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(None) + SIZEOF(None)) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.self.condition.self.conditional_operator.self.name == 'implication') + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ratio_measure_with_unit # +#################### +class ratio_measure_with_unit(measure_with_unit): + '''Entity ratio_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.RATIO_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY rectangular_pattern # +#################### +class rectangular_pattern(replicate_feature): + '''Entity rectangular_pattern definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + replicate_feature.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + +#################### + # ENTITY general_feature # +#################### +class general_feature(feature_definition): + '''Entity general_feature definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + feature_definition.__init__(self , inherited0__name , inherited1__description , ) + def wr1(self): + eval_wr1_wr = ((SIZEOF(get_property_definition_representations(self)) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == SIZEOF(None)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == SIZEOF(None)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == SIZEOF(None)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY tee_profile # +#################### +class tee_profile(shape_aspect): + '''Entity tee_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 0) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (SIZEOF(None) == 1) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (SIZEOF(None) == 1) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + def wr10(self): + eval_wr10_wr = (SIZEOF(None) == 1) + if not eval_wr10_wr: + raise AssertionError('Rule wr10 violated') + else: + return eval_wr10_wr + + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 1) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(None) == 1) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = (SIZEOF(None) == 1) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + def wr14(self): + eval_wr14_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr14_wr: + raise AssertionError('Rule wr14 violated') + else: + return eval_wr14_wr + + def wr15(self): + eval_wr15_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr15_wr: + raise AssertionError('Rule wr15 violated') + else: + return eval_wr15_wr + + +#################### + # ENTITY universal_pair_value # +#################### +class universal_pair_value(pair_value): + '''Entity universal_pair_value definition. + + :param pair_value_applies_to_pair + :type pair_value_applies_to_pair:universal_pair + + :param first_rotation_angle + :type first_rotation_angle:plane_angle_measure + + :param second_rotation_angle + :type second_rotation_angle:plane_angle_measure + ''' + def __init__( self , inherited0__applies_to_pair , pair_value_applies_to_pair,first_rotation_angle,second_rotation_angle, ): + pair_value.__init__(self , inherited0__applies_to_pair , ) + self.pair_value_applies_to_pair = pair_value_applies_to_pair + self.first_rotation_angle = first_rotation_angle + self.second_rotation_angle = second_rotation_angle + + @apply + def pair_value_applies_to_pair(): + def fget( self ): + return self._pair_value_applies_to_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pair_value_applies_to_pair is mantatory and can not be set to None') + if not check_type(value,universal_pair): + self._pair_value_applies_to_pair = universal_pair(value) + else: + self._pair_value_applies_to_pair = value + return property(**locals()) + + @apply + def first_rotation_angle(): + def fget( self ): + return self._first_rotation_angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument first_rotation_angle is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._first_rotation_angle = plane_angle_measure(value) + else: + self._first_rotation_angle = value + return property(**locals()) + + @apply + def second_rotation_angle(): + def fget( self ): + return self._second_rotation_angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument second_rotation_angle is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._second_rotation_angle = plane_angle_measure(value) + else: + self._second_rotation_angle = value + return property(**locals()) + +#################### + # ENTITY pre_defined_point_marker_symbol # +#################### +class pre_defined_point_marker_symbol(pre_defined_marker,pre_defined_symbol): + '''Entity pre_defined_point_marker_symbol definition. + ''' + def __init__( self , inherited0__name , inherited1__name , ): + pre_defined_marker.__init__(self , inherited0__name , ) + pre_defined_symbol.__init__(self , inherited1__name , ) + def wr1(self): + eval_wr1_wr = (self.self.name == ['asterisk','circle','dot','plus','square','triangle','x']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY sphere # +#################### +class sphere(geometric_representation_item): + '''Entity sphere definition. + + :param radius + :type radius:positive_length_measure + + :param centre + :type centre:point + ''' + def __init__( self , inherited0__name , radius,centre, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.radius = radius + self.centre = centre + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._radius = positive_length_measure(value) + else: + self._radius = value + return property(**locals()) + + @apply + def centre(): + def fget( self ): + return self._centre + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument centre is mantatory and can not be set to None') + if not check_type(value,point): + self._centre = point(value) + else: + self._centre = value + return property(**locals()) + +#################### + # ENTITY cylindrical_surface # +#################### +class cylindrical_surface(elementary_surface): + '''Entity cylindrical_surface definition. + + :param radius + :type radius:positive_length_measure + ''' + def __init__( self , inherited0__name , inherited1__position , radius, ): + elementary_surface.__init__(self , inherited0__name , inherited1__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._radius = positive_length_measure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY general_property_relationship # +#################### +class general_property_relationship(BaseEntityClass): + '''Entity general_property_relationship definition. + + :param name + :type name:label + + :param description + :type description:text + + :param relating_property + :type relating_property:general_property + + :param related_property + :type related_property:general_property + ''' + def __init__( self , name,description,relating_property,related_property, ): + self.name = name + self.description = description + self.relating_property = relating_property + self.related_property = related_property + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relating_property(): + def fget( self ): + return self._relating_property + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relating_property is mantatory and can not be set to None') + if not check_type(value,general_property): + self._relating_property = general_property(value) + else: + self._relating_property = value + return property(**locals()) + + @apply + def related_property(): + def fget( self ): + return self._related_property + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument related_property is mantatory and can not be set to None') + if not check_type(value,general_property): + self._related_property = general_property(value) + else: + self._related_property = value + return property(**locals()) + +#################### + # ENTITY local_time # +#################### +class local_time(BaseEntityClass): + '''Entity local_time definition. + + :param hour_component + :type hour_component:hour_in_day + + :param minute_component + :type minute_component:minute_in_hour + + :param second_component + :type second_component:second_in_minute + + :param zone + :type zone:coordinated_universal_time_offset + ''' + def __init__( self , hour_component,minute_component,second_component,zone, ): + self.hour_component = hour_component + self.minute_component = minute_component + self.second_component = second_component + self.zone = zone + + @apply + def hour_component(): + def fget( self ): + return self._hour_component + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hour_component is mantatory and can not be set to None') + if not check_type(value,hour_in_day): + self._hour_component = hour_in_day(value) + else: + self._hour_component = value + return property(**locals()) + + @apply + def minute_component(): + def fget( self ): + return self._minute_component + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,minute_in_hour): + self._minute_component = minute_in_hour(value) + else: + self._minute_component = value + else: + self._minute_component = value + return property(**locals()) + + @apply + def second_component(): + def fget( self ): + return self._second_component + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,second_in_minute): + self._second_component = second_in_minute(value) + else: + self._second_component = value + else: + self._second_component = value + return property(**locals()) + + @apply + def zone(): + def fget( self ): + return self._zone + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument zone is mantatory and can not be set to None') + if not check_type(value,coordinated_universal_time_offset): + self._zone = coordinated_universal_time_offset(value) + else: + self._zone = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = valid_time(self) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY mass_unit # +#################### +class mass_unit(named_unit): + '''Entity mass_unit definition. + ''' + def __init__( self , inherited0__dimensions , ): + named_unit.__init__(self , inherited0__dimensions , ) + def wr1(self): + eval_wr1_wr = (((((((self.self.named_unit.self.dimensions.self.length_exponent == 0) and (self.self.named_unit.self.dimensions.self.mass_exponent == 1)) and (self.self.named_unit.self.dimensions.self.time_exponent == 0)) and (self.self.named_unit.self.dimensions.self.electric_current_exponent == 0)) and (self.self.named_unit.self.dimensions.self.thermodynamic_temperature_exponent == 0)) and (self.self.named_unit.self.dimensions.self.amount_of_substance_exponent == 0)) and (self.self.named_unit.self.dimensions.self.luminous_intensity_exponent == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY symbol_colour # +#################### +class symbol_colour(BaseEntityClass): + '''Entity symbol_colour definition. + + :param colour_of_symbol + :type colour_of_symbol:colour + ''' + def __init__( self , colour_of_symbol, ): + self.colour_of_symbol = colour_of_symbol + + @apply + def colour_of_symbol(): + def fget( self ): + return self._colour_of_symbol + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colour_of_symbol is mantatory and can not be set to None') + if not check_type(value,colour): + self._colour_of_symbol = colour(value) + else: + self._colour_of_symbol = value + return property(**locals()) + +#################### + # ENTITY solid_replica # +#################### +class solid_replica(solid_model): + '''Entity solid_replica definition. + + :param parent_solid + :type parent_solid:solid_model + + :param transformation + :type transformation:cartesian_transformation_operator_3d + ''' + def __init__( self , inherited0__name , parent_solid,transformation, ): + solid_model.__init__(self , inherited0__name , ) + self.parent_solid = parent_solid + self.transformation = transformation + + @apply + def parent_solid(): + def fget( self ): + return self._parent_solid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parent_solid is mantatory and can not be set to None') + if not check_type(value,solid_model): + self._parent_solid = solid_model(value) + else: + self._parent_solid = value + return property(**locals()) + + @apply + def transformation(): + def fget( self ): + return self._transformation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transformation is mantatory and can not be set to None') + if not check_type(value,cartesian_transformation_operator_3d): + self._transformation = cartesian_transformation_operator_3d(value) + else: + self._transformation = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = acyclic_solid_replica(self,self.parent_solid) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.parent_solid.self.geometric_representation_item.self.dim == 3) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY material_designation_characterization # +#################### +class material_designation_characterization(BaseEntityClass): + '''Entity material_designation_characterization definition. + + :param name + :type name:label + + :param description + :type description:text + + :param designation + :type designation:material_designation + + :param property + :type property:characterized_material_property + ''' + def __init__( self , name,description,designation,property, ): + self.name = name + self.description = description + self.designation = designation + self.property = property + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def designation(): + def fget( self ): + return self._designation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument designation is mantatory and can not be set to None') + if not check_type(value,material_designation): + self._designation = material_designation(value) + else: + self._designation = value + return property(**locals()) + + @apply + def property(): + def fget( self ): + return self._property + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument property is mantatory and can not be set to None') + if not check_type(value,characterized_material_property): + self._property = characterized_material_property(value) + else: + self._property = value + return property(**locals()) + +#################### + # ENTITY coaxiality_tolerance # +#################### +class coaxiality_tolerance(geometric_tolerance_with_datum_reference): + '''Entity coaxiality_tolerance definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ): + geometric_tolerance_with_datum_reference.__init__(self , inherited0__name , inherited1__description , inherited2__magnitude , inherited3__toleranced_shape_aspect , inherited4__datum_system , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.geometric_tolerance_with_datum_reference.self.datum_system) <= 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY minimum_function # +#################### +class minimum_function(multiple_arity_function_call): + '''Entity minimum_function definition. + ''' + def __init__( self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ): + multiple_arity_function_call.__init__(self , inherited0__operands , inherited1__multiple_arity_generic_expression_operands , ) + +#################### + # ENTITY poly_loop # +#################### +class poly_loop(loop,geometric_representation_item): + '''Entity poly_loop definition. + + :param polygon + :type polygon:LIST(3,None,'cartesian_point', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__name , polygon, ): + loop.__init__(self , inherited0__name , ) + geometric_representation_item.__init__(self , inherited1__name , ) + self.polygon = polygon + + @apply + def polygon(): + def fget( self ): + return self._polygon + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument polygon is mantatory and can not be set to None') + if not check_type(value,LIST(3,None,'cartesian_point', scope = schema_scope)): + self._polygon = LIST(value) + else: + self._polygon = value + return property(**locals()) + +#################### + # ENTITY surface_rendering_properties # +#################### +class surface_rendering_properties(BaseEntityClass): + '''Entity surface_rendering_properties definition. + + :param rendered_colour + :type rendered_colour:colour + ''' + def __init__( self , rendered_colour, ): + self.rendered_colour = rendered_colour + + @apply + def rendered_colour(): + def fget( self ): + return self._rendered_colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rendered_colour is mantatory and can not be set to None') + if not check_type(value,colour): + self._rendered_colour = colour(value) + else: + self._rendered_colour = value + return property(**locals()) + +#################### + # ENTITY camera_image_2d_with_scale # +#################### +class camera_image_2d_with_scale(camera_image): + '''Entity camera_image_2d_with_scale definition. + + :param scale + :type scale:positive_ratio_measure + ''' + def __init__( self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , inherited3__mapped_item_mapping_source , inherited4__mapped_item_mapping_target , ): + camera_image.__init__(self , inherited0__name , inherited1__mapping_source , inherited2__mapping_target , inherited3__mapped_item_mapping_source , inherited4__mapped_item_mapping_target , ) + + @apply + def scale(): + def fget( self ): + attribute_eval = (self.self.mapped_item.self.mapping_target.self.planar_extent.self.size_in_x / self.self.mapped_item.self.mapping_source.self.mapping_origin.self.camera_model_d2.self.view_window.self.planar_extent.self.size_in_x) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scale is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'CAMERA_MODEL_D2') == TYPEOF(self.self.mapped_item.self.mapping_source.self.mapping_origin)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (aspect_ratio(self.self.mapped_item.self.mapping_target) == aspect_ratio(self.self.mapped_item.self.mapping_source.self.mapping_origin.self.camera_model_d2.self.view_window)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = self.self.mapped_item.self.mapping_source.self.mapping_origin.self.camera_model_d2.self.view_window_clipping + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY draughting_model_item_association # +#################### +class draughting_model_item_association(item_identified_representation_usage): + '''Entity draughting_model_item_association definition. + + :param item_identified_representation_usage_definition + :type item_identified_representation_usage_definition:shape_aspect + + :param item_identified_representation_usage_used_representation + :type item_identified_representation_usage_used_representation:draughting_model + + :param item_identified_representation_usage_identified_item + :type item_identified_representation_usage_identified_item:draughting_model_item_association_select + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__definition , inherited3__used_representation , inherited4__identified_item , item_identified_representation_usage_definition,item_identified_representation_usage_used_representation,item_identified_representation_usage_identified_item, ): + item_identified_representation_usage.__init__(self , inherited0__name , inherited1__description , inherited2__definition , inherited3__used_representation , inherited4__identified_item , ) + self.item_identified_representation_usage_definition = item_identified_representation_usage_definition + self.item_identified_representation_usage_used_representation = item_identified_representation_usage_used_representation + self.item_identified_representation_usage_identified_item = item_identified_representation_usage_identified_item + + @apply + def item_identified_representation_usage_definition(): + def fget( self ): + return self._item_identified_representation_usage_definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_identified_representation_usage_definition is mantatory and can not be set to None') + if not check_type(value,shape_aspect): + self._item_identified_representation_usage_definition = shape_aspect(value) + else: + self._item_identified_representation_usage_definition = value + return property(**locals()) + + @apply + def item_identified_representation_usage_used_representation(): + def fget( self ): + return self._item_identified_representation_usage_used_representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_identified_representation_usage_used_representation is mantatory and can not be set to None') + if not check_type(value,draughting_model): + self._item_identified_representation_usage_used_representation = draughting_model(value) + else: + self._item_identified_representation_usage_used_representation = value + return property(**locals()) + + @apply + def item_identified_representation_usage_identified_item(): + def fget( self ): + return self._item_identified_representation_usage_identified_item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item_identified_representation_usage_identified_item is mantatory and can not be set to None') + if not check_type(value,draughting_model_item_association_select): + self._item_identified_representation_usage_identified_item = draughting_model_item_association_select(value) + else: + self._item_identified_representation_usage_identified_item = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'DATUM_FEATURE_CALLOUT') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or (('AUTOMOTIVE_DESIGN.' + 'DATUM_FEATURE') == TYPEOF(self.self.item_identified_representation_usage.self.definition))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'DATUM_TARGET_CALLOUT') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or (('AUTOMOTIVE_DESIGN.' + 'DATUM_TARGET') == TYPEOF(self.self.item_identified_representation_usage.self.definition))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'ANGULAR_DIMENSION') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or (('AUTOMOTIVE_DESIGN.' + 'ANGULAR_SIZE') == TYPEOF(self.self.item_identified_representation_usage.self.definition))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'CURVE_DIMENSION') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or ((('AUTOMOTIVE_DESIGN.' + 'DIMENSIONAL_SIZE') == TYPEOF(self.self.item_identified_representation_usage.self.definition)) and (self.self.item_identified_representation_usage.self.definition.self.name == 'curve dimension'))) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'DIAMETER_DIMENSION') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or ((('AUTOMOTIVE_DESIGN.' + 'DIMENSIONAL_SIZE') == TYPEOF(self.self.item_identified_representation_usage.self.definition)) and (self.self.item_identified_representation_usage.self.definition.self.name == 'diameter'))) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'LINEAR_DIMENSION') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or ((('AUTOMOTIVE_DESIGN.' + 'DIMENSIONAL_SIZE') == TYPEOF(self.self.item_identified_representation_usage.self.definition)) and (((self.self.item_identified_representation_usage.self.definition.self.name == 'heigth') or (self.self.item_identified_representation_usage.self.definition.self.name == 'length')) or (self.self.item_identified_representation_usage.self.definition.self.name == 'width')))) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'RADIUS_DIMENSION') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or ((('AUTOMOTIVE_DESIGN.' + 'DIMENSIONAL_SIZE') == TYPEOF(self.self.item_identified_representation_usage.self.definition)) and (self.self.item_identified_representation_usage.self.definition.self.name == 'radius'))) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = (( not (('AUTOMOTIVE_DESIGN.' + 'GEOMETRICAL_TOLERANCE_CALLOUT') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or (('AUTOMOTIVE_DESIGN.' + 'GEOMETRIC_TOLERANCE') == TYPEOF(self.self.item_identified_representation_usage.self.definition))) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + def wr9(self): + eval_wr9_wr = (((((( not (('AUTOMOTIVE_DESIGN.' + 'DIMENSIONAL_SIZE') == TYPEOF(self.self.item_identified_representation_usage.self.definition))) or (('AUTOMOTIVE_DESIGN.' + 'DIMENSION_CALLOUT') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or (('AUTOMOTIVE_DESIGN.' + 'DIMENSION_CURVE_DIRECTED_CALLOUT') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or (('AUTOMOTIVE_DESIGN.' + 'LEADER_DIRECTED_DIMENSION') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or (('AUTOMOTIVE_DESIGN.' + 'ORDINATE_DIMENSION') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) or (('AUTOMOTIVE_DESIGN.' + 'STRUCTURED_DIMENSION_CALLOUT') == TYPEOF(self.self.item_identified_representation_usage.self.identified_item))) + if not eval_wr9_wr: + raise AssertionError('Rule wr9 violated') + else: + return eval_wr9_wr + + +#################### + # ENTITY surface_style_boundary # +#################### +class surface_style_boundary(founded_item): + '''Entity surface_style_boundary definition. + + :param style_of_boundary + :type style_of_boundary:curve_or_render + ''' + def __init__( self , style_of_boundary, ): + founded_item.__init__(self , ) + self.style_of_boundary = style_of_boundary + + @apply + def style_of_boundary(): + def fget( self ): + return self._style_of_boundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument style_of_boundary is mantatory and can not be set to None') + if not check_type(value,curve_or_render): + self._style_of_boundary = curve_or_render(value) + else: + self._style_of_boundary = value + return property(**locals()) + +#################### + # ENTITY area_unit # +#################### +class area_unit(derived_unit): + '''Entity area_unit definition. + ''' + def __init__( self , inherited0__elements , ): + derived_unit.__init__(self , inherited0__elements , ) + def wr1(self): + eval_wr1_wr = (derive_dimensional_exponents(self) == dimensional_exponents(2,0,0,0,0,0,0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY offset_curve_2d # +#################### +class offset_curve_2d(curve): + '''Entity offset_curve_2d definition. + + :param basis_curve + :type basis_curve:curve + + :param distance + :type distance:length_measure + + :param self_intersect + :type self_intersect:LOGICAL + ''' + def __init__( self , inherited0__name , basis_curve,distance,self_intersect, ): + curve.__init__(self , inherited0__name , ) + self.basis_curve = basis_curve + self.distance = distance + self.self_intersect = self_intersect + + @apply + def basis_curve(): + def fget( self ): + return self._basis_curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basis_curve is mantatory and can not be set to None') + if not check_type(value,curve): + self._basis_curve = curve(value) + else: + self._basis_curve = value + return property(**locals()) + + @apply + def distance(): + def fget( self ): + return self._distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distance is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._distance = length_measure(value) + else: + self._distance = value + return property(**locals()) + + @apply + def self_intersect(): + def fget( self ): + return self._self_intersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument self_intersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._self_intersect = LOGICAL(value) + else: + self._self_intersect = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.basis_curve.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY shape_definition_representation # +#################### +class shape_definition_representation(property_definition_representation): + '''Entity shape_definition_representation definition. + ''' + def __init__( self , inherited0__definition , inherited1__used_representation , ): + property_definition_representation.__init__(self , inherited0__definition , inherited1__used_representation , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.PRODUCT_DEFINITION_SHAPE' == TYPEOF(self.self.definition)) or ('AUTOMOTIVE_DESIGN.SHAPE_DEFINITION' == TYPEOF(self.self.definition.self.definition))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION' == TYPEOF(self.self.used_representation)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY symbol_style # +#################### +class symbol_style(founded_item): + '''Entity symbol_style definition. + + :param name + :type name:label + + :param style_of_symbol + :type style_of_symbol:symbol_style_select + ''' + def __init__( self , name,style_of_symbol, ): + founded_item.__init__(self , ) + self.name = name + self.style_of_symbol = style_of_symbol + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def style_of_symbol(): + def fget( self ): + return self._style_of_symbol + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument style_of_symbol is mantatory and can not be set to None') + if not check_type(value,symbol_style_select): + self._style_of_symbol = symbol_style_select(value) + else: + self._style_of_symbol = value + return property(**locals()) + +#################### + # ENTITY tactile_appearance_representation # +#################### +class tactile_appearance_representation(representation): + '''Entity tactile_appearance_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) <= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((SIZEOF(USEDIN(self,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.USED_REPRESENTATION')) == 1) and (SIZEOF(None) == 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY volume_unit # +#################### +class volume_unit(derived_unit): + '''Entity volume_unit definition. + ''' + def __init__( self , inherited0__elements , ): + derived_unit.__init__(self , inherited0__elements , ) + def wr1(self): + eval_wr1_wr = (derive_dimensional_exponents(self) == dimensional_exponents(3,0,0,0,0,0,0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY conical_surface # +#################### +class conical_surface(elementary_surface): + '''Entity conical_surface definition. + + :param radius + :type radius:length_measure + + :param semi_angle + :type semi_angle:plane_angle_measure + ''' + def __init__( self , inherited0__name , inherited1__position , radius,semi_angle, ): + elementary_surface.__init__(self , inherited0__name , inherited1__position , ) + self.radius = radius + self.semi_angle = semi_angle + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,length_measure): + self._radius = length_measure(value) + else: + self._radius = value + return property(**locals()) + + @apply + def semi_angle(): + def fget( self ): + return self._semi_angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semi_angle is mantatory and can not be set to None') + if not check_type(value,plane_angle_measure): + self._semi_angle = plane_angle_measure(value) + else: + self._semi_angle = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.radius >= 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY applied_person_and_organization_assignment # +#################### +class applied_person_and_organization_assignment(person_and_organization_assignment): + '''Entity applied_person_and_organization_assignment definition. + + :param items + :type items:SET(1,None,'person_and_organization_item', scope = schema_scope) + ''' + def __init__( self , inherited0__assigned_person_and_organization , inherited1__role , items, ): + person_and_organization_assignment.__init__(self , inherited0__assigned_person_and_organization , inherited1__role , ) + self.items = items + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'person_and_organization_item', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not (self.self.role.self.name == 'signing for contract')) or item_correlation(self.self.items,['APPLIED_ORGANIZATION_ASSIGNMENT'])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY block # +#################### +class block(geometric_representation_item): + '''Entity block definition. + + :param position + :type position:axis2_placement_3d + + :param x + :type x:positive_length_measure + + :param y + :type y:positive_length_measure + + :param z + :type z:positive_length_measure + ''' + def __init__( self , inherited0__name , position,x,y,z, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.position = position + self.x = x + self.y = y + self.z = z + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,axis2_placement_3d): + self._position = axis2_placement_3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def x(): + def fget( self ): + return self._x + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument x is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._x = positive_length_measure(value) + else: + self._x = value + return property(**locals()) + + @apply + def y(): + def fget( self ): + return self._y + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument y is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._y = positive_length_measure(value) + else: + self._y = value + return property(**locals()) + + @apply + def z(): + def fget( self ): + return self._z + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument z is mantatory and can not be set to None') + if not check_type(value,positive_length_measure): + self._z = positive_length_measure(value) + else: + self._z = value + return property(**locals()) + +#################### + # ENTITY global_unit_assigned_context # +#################### +class global_unit_assigned_context(representation_context): + '''Entity global_unit_assigned_context definition. + + :param units + :type units:SET(1,None,'unit', scope = schema_scope) + ''' + def __init__( self , inherited0__context_identifier , inherited1__context_type , units, ): + representation_context.__init__(self , inherited0__context_identifier , inherited1__context_type , ) + self.units = units + + @apply + def units(): + def fget( self ): + return self._units + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument units is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'unit', scope = schema_scope)): + self._units = SET(value) + else: + self._units = value + return property(**locals()) + +#################### + # ENTITY placed_feature # +#################### +class placed_feature(shape_aspect): + '''Entity placed_feature definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'PRODUCT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY surface_style_parameter_line # +#################### +class surface_style_parameter_line(founded_item): + '''Entity surface_style_parameter_line definition. + + :param style_of_parameter_lines + :type style_of_parameter_lines:curve_or_render + + :param direction_counts + :type direction_counts:SET(1,2,'direction_count_select', scope = schema_scope) + ''' + def __init__( self , style_of_parameter_lines,direction_counts, ): + founded_item.__init__(self , ) + self.style_of_parameter_lines = style_of_parameter_lines + self.direction_counts = direction_counts + + @apply + def style_of_parameter_lines(): + def fget( self ): + return self._style_of_parameter_lines + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument style_of_parameter_lines is mantatory and can not be set to None') + if not check_type(value,curve_or_render): + self._style_of_parameter_lines = curve_or_render(value) + else: + self._style_of_parameter_lines = value + return property(**locals()) + + @apply + def direction_counts(): + def fget( self ): + return self._direction_counts + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument direction_counts is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'direction_count_select', scope = schema_scope)): + self._direction_counts = SET(value) + else: + self._direction_counts = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((HIINDEX(self.self.direction_counts) == 1) XOR (TYPEOF(self.self.direction_counts[1]) != TYPEOF(self.self.direction_counts[2]))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY surface_side_style # +#################### +class surface_side_style(founded_item): + '''Entity surface_side_style definition. + + :param name + :type name:label + + :param styles + :type styles:SET(1,7,'surface_style_element_select', scope = schema_scope) + ''' + def __init__( self , name,styles, ): + founded_item.__init__(self , ) + self.name = name + self.styles = styles + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def styles(): + def fget( self ): + return self._styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styles is mantatory and can not be set to None') + if not check_type(value,SET(1,7,'surface_style_element_select', scope = schema_scope)): + self._styles = SET(value) + else: + self._styles = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY time_measure_with_unit # +#################### +class time_measure_with_unit(measure_with_unit): + '''Entity time_measure_with_unit definition. + ''' + def __init__( self , inherited0__value_component , inherited1__unit_component , ): + measure_with_unit.__init__(self , inherited0__value_component , inherited1__unit_component , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.TIME_UNIT' == TYPEOF(self.self.measure_with_unit.self.unit_component)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY action_property_representation # +#################### +class action_property_representation(BaseEntityClass): + '''Entity action_property_representation definition. + + :param name + :type name:label + + :param description + :type description:text + + :param property + :type property:action_property + + :param representation + :type representation:representation + ''' + def __init__( self , name,description,property,representation, ): + self.name = name + self.description = description + self.property = property + self.representation = representation + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument description is mantatory and can not be set to None') + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + return property(**locals()) + + @apply + def property(): + def fget( self ): + return self._property + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument property is mantatory and can not be set to None') + if not check_type(value,action_property): + self._property = action_property(value) + else: + self._property = value + return property(**locals()) + + @apply + def representation(): + def fget( self ): + return self._representation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representation is mantatory and can not be set to None') + if not check_type(value,representation): + self._representation = representation(value) + else: + self._representation = value + return property(**locals()) + +#################### + # ENTITY angular_dimension # +#################### +class angular_dimension(dimension_curve_directed_callout): + '''Entity angular_dimension definition. + ''' + def __init__( self , inherited0__name , inherited1__contents , ): + dimension_curve_directed_callout.__init__(self , inherited0__name , inherited1__contents , ) + +#################### + # ENTITY boolean_literal # +#################### +class boolean_literal(simple_boolean_expression,generic_literal): + '''Entity boolean_literal definition. + + :param the_value + :type the_value:BOOLEAN + ''' + def __init__( self , the_value, ): + simple_boolean_expression.__init__(self , ) + generic_literal.__init__(self , ) + self.the_value = the_value + + @apply + def the_value(): + def fget( self ): + return self._the_value + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument the_value is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._the_value = BOOLEAN(value) + else: + self._the_value = value + return property(**locals()) + +#################### + # ENTITY defined_symbol # +#################### +class defined_symbol(geometric_representation_item): + '''Entity defined_symbol definition. + + :param definition + :type definition:defined_symbol_select + + :param target + :type target:symbol_target + ''' + def __init__( self , inherited0__name , definition,target, ): + geometric_representation_item.__init__(self , inherited0__name , ) + self.definition = definition + self.target = target + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definition is mantatory and can not be set to None') + if not check_type(value,defined_symbol_select): + self._definition = defined_symbol_select(value) + else: + self._definition = value + return property(**locals()) + + @apply + def target(): + def fget( self ): + return self._target + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument target is mantatory and can not be set to None') + if not check_type(value,symbol_target): + self._target = symbol_target(value) + else: + self._target = value + return property(**locals()) + +#################### + # ENTITY dimension_text_associativity # +#################### +class dimension_text_associativity(text_literal,mapped_item): + '''Entity dimension_text_associativity definition. + ''' + def __init__( self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , inherited6__name , inherited7__mapping_source , inherited8__mapping_target , ): + text_literal.__init__(self , inherited0__name , inherited1__literal , inherited2__placement , inherited3__alignment , inherited4__path , inherited5__font , ) + mapped_item.__init__(self , inherited6__name , inherited7__mapping_source , inherited8__mapping_target , ) + def wr1(self): + eval_wr1_wr = ('AUTOMOTIVE_DESIGN.SHAPE_DIMENSION_REPRESENTATION' == TYPEOF(self.self.mapped_item.self.mapping_source.self.mapped_representation)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('AUTOMOTIVE_DESIGN.DRAUGHTING_CALLOUT' == TYPEOF(self.self.mapped_item.self.mapping_target)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY organizational_project_role # +#################### +class organizational_project_role(BaseEntityClass): + '''Entity organizational_project_role definition. + + :param name + :type name:label + + :param description + :type description:text + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,text): + self._description = text(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY pair_actuator # +#################### +class pair_actuator(BaseEntityClass): + '''Entity pair_actuator definition. + + :param actuated_pair + :type actuated_pair:kinematic_pair + + :param name + :type name:label + ''' + def __init__( self , actuated_pair,name, ): + self.actuated_pair = actuated_pair + self.name = name + + @apply + def actuated_pair(): + def fget( self ): + return self._actuated_pair + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actuated_pair is mantatory and can not be set to None') + if not check_type(value,kinematic_pair): + self._actuated_pair = kinematic_pair(value) + else: + self._actuated_pair = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,label): + self._name = label(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY partial_circular_profile # +#################### +class partial_circular_profile(shape_aspect): + '''Entity partial_circular_profile definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ): + shape_aspect.__init__(self , inherited0__name , inherited1__description , inherited2__of_shape , inherited3__product_definitional , ) + def wr1(self): + eval_wr1_wr = (('AUTOMOTIVE_DESIGN.' + 'FEATURE_COMPONENT_DEFINITION') == TYPEOF(self.self.of_shape.self.definition)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 1) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (SIZEOF(None) == 1) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = (SIZEOF(None) == 1) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + def wr6(self): + eval_wr6_wr = (SIZEOF(None) == 1) + if not eval_wr6_wr: + raise AssertionError('Rule wr6 violated') + else: + return eval_wr6_wr + + def wr7(self): + eval_wr7_wr = (SIZEOF(None) == 1) + if not eval_wr7_wr: + raise AssertionError('Rule wr7 violated') + else: + return eval_wr7_wr + + def wr8(self): + eval_wr8_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) == SIZEOF(None))) + if not eval_wr8_wr: + raise AssertionError('Rule wr8 violated') + else: + return eval_wr8_wr + + +#################### + # ENTITY point_placement_shape_representation # +#################### +class point_placement_shape_representation(shape_representation): + '''Entity point_placement_shape_representation definition. + ''' + def __init__( self , inherited0__name , inherited1__items , inherited2__context_of_items , ): + shape_representation.__init__(self , inherited0__name , inherited1__items , inherited2__context_of_items , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # FUNCTION check_associative_shape_aspects # +#################### +def check_associative_shape_aspects(sdr,): + ''' + :param sdr + :type sdr:shape_definition_representation + ''' + if (SIZEOF(sdr.used_representation.items) != 2): + return FALSE + sr1 = using_representations(sdr.used_representation.items[1]) + sr2 = using_representations(sdr.used_representation.items[2]) + for i in range(1,HIINDEX(sr1),1): + dm = representations_mapped_into(sr1[i]) + for j in range(1,HIINDEX(dm),1): + if ('AUTOMOTIVE_DESIGN.DRAUGHTING_MODEL' == TYPEOF(dm[j])): + if (dm[j] == sr2): + return TRUE + pv = representations_mapped_into(dm[j]) + for k in range(1,HIINDEX(pv),1): + if ('AUTOMOTIVE_DESIGN.PRESENTATION_VIEW' == TYPEOF(pv[k])): + if (pv[k] == sr2): + return TRUE + for i in range(1,HIINDEX(sr2),1): + dm = representations_mapped_into(sr2[i]) + for j in range(1,HIINDEX(dm),1): + if ('AUTOMOTIVE_DESIGN.DRAUGHTING_MODEL' == TYPEOF(dm[j])): + if (dm[j] == sr1): + return TRUE + pv = representations_mapped_into(dm[j]) + for k in range(1,HIINDEX(pv),1): + if ('AUTOMOTIVE_DESIGN.PRESENTATION_VIEW' == TYPEOF(pv[k])): + if (pv[k] == sr1): + return TRUE + return FALSE + +#################### + # FUNCTION build_2axes # +#################### +def build_2axes(ref_direction,): + ''' + :param ref_direction + :type ref_direction:direction + ''' + return [d,orthogonal_complement(d)] + +#################### + # FUNCTION get_round_holes_for_composite_hole # +#################### +def get_round_holes_for_composite_hole(sar_instance_set,): + ''' + :param sar_instance_set + :type sar_instance_set:(null) + ''' + for i in range(1,HIINDEX(sar_instance_set),1): + if (SIZEOF(['AUTOMOTIVE_DESIGN.INSTANCED_FEATURE','AUTOMOTIVE_DESIGN.ROUND_HOLE'] * TYPEOF(sar_instance_set[i].related_shape_aspect)) >= 2): + rh_set = rh_set + sar_instance_set[i].related_shape_aspect.round_hole + if ('AUTOMOTIVE_DESIGN.PLACED_FEATURE' == TYPEOF(sar_instance_set[i])): + pdr_set = get_shape_aspect_property_definition_representations(sar_instance_set[i].related_shape_aspect) + for j in range(1,HIINDEX(pdr_set),1): + if ((pdr_set[j].used_representation.name == 'feature definition placement') and ('AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION' == TYPEOF(pdr_set[j].used_representation))): + ri_set = pdr_set[j].used_representation.items + for k in range(1,HIINDEX(ri_set),1): + if (('AUTOMOTIVE_DESIGN.MAPPED_ITEM' == TYPEOF(ri_set[k])) and (('AUTOMOTIVE_DESIGN.' + 'SHAPE_REPRESENTATION_WITH_PARAMETERS') == TYPEOF(ri_set[k].mapped_item.mapping_source.mapped_representation))): + pdr_set1 = bag_to_set(USEDIN(ri_set[k].mapped_item.mapping_source.mapped_representation,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.USED_REPRESENTATION')) + for l in range(1,HIINDEX(pdr_set1),1): + if ('AUTOMOTIVE_DESIGN.ROUND_HOLE' == TYPEOF(pdr_set1[l].definition.definition)): + rh_set = rh_set + pdr_set1[l].definition.definition + return rh_set + +#################### + # FUNCTION item_in_context # +#################### +def item_in_context(item,cntxt,): + ''' + :param item + :type item:representation_item + :param cntxt + :type cntxt:representation_context + ''' + if (SIZEOF(USEDIN(item,'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') * cntxt.representations_in_context) > 0): + return TRUE + else: + y = None + if (SIZEOF(y) > 0): + for i in range(1,HIINDEX(y),1): + if (item_in_context(y[i],cntxt)): + return TRUE + return FALSE + +#################### + # FUNCTION default_tolerance_table_cell_wr3 # +#################### +def default_tolerance_table_cell_wr3(agg,): + ''' + :param agg + :type agg:(null) + ''' + if ((SIZEOF(None) == 1) or ((SIZEOF(None) == 1) and (SIZEOF(None) == 1))): + return TRUE + else: + return FALSE + +#################### + # FUNCTION default_tolerance_table_cell_wr2 # +#################### +def default_tolerance_table_cell_wr2(agg,): + ''' + :param agg + :type agg:(null) + ''' + if (SIZEOF(agg) <= 5): + return TRUE + else: + return FALSE + +#################### + # FUNCTION gbsf_check_point # +#################### +def gbsf_check_point(pnt,): + ''' + :param pnt + :type pnt:point + ''' + if ('AUTOMOTIVE_DESIGN.CARTESIAN_POINT' == TYPEOF(pnt)): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.POINT_ON_CURVE' == TYPEOF(pnt)): + return gbsf_check_curve(pnt.point_on_curve.basis_curve) + else: + if ('AUTOMOTIVE_DESIGN.POINT_ON_SURFACE' == TYPEOF(pnt)): + return gbsf_check_surface(pnt.point_on_surface.basis_surface) + else: + if ('AUTOMOTIVE_DESIGN.DEGENERATE_PCURVE' == TYPEOF(pnt)): + return gbsf_check_curve(pnt.degenerate_pcurve.reference_to_curve.representation.items[1]) and gbsf_check_surface(pnt.degenerate_pcurve.basis_surface) + return FALSE + +#################### + # FUNCTION acyclic_solid_replica # +#################### +def acyclic_solid_replica(rep,parent,): + ''' + :param rep + :type rep:solid_replica + :param parent + :type parent:solid_model + ''' + if ( not ('AUTOMOTIVE_DESIGN.SOLID_REPLICA' == TYPEOF(parent))): + return TRUE + if (parent == rep): + return FALSE + else: + return acyclic_solid_replica(rep,parent.solid_replica.parent_solid) + +#################### + # FUNCTION build_axes # +#################### +def build_axes(axis,ref_direction,): + ''' + :param axis + :type axis:direction + :param ref_direction + :type ref_direction:direction + ''' + d1 = NVL(normalise(axis),dummy_gri == direction([0,0,1])) + d2 = first_proj_axis(d1,ref_direction) + return [d2,normalise(cross_product(d1,d2)).vector.orientation,d1] + +#################### + # FUNCTION edge_reversed # +#################### +def edge_reversed(an_edge,): + ''' + :param an_edge + :type an_edge:edge + ''' + if ('AUTOMOTIVE_DESIGN.ORIENTED_EDGE' == TYPEOF(an_edge)): + the_reverse = (dummy_tri == edge(an_edge.edge_end,an_edge.edge_start)) == oriented_edge(an_edge.oriented_edge.edge_element, not an_edge.oriented_edge.orientation) + else: + the_reverse = (dummy_tri == edge(an_edge.edge_end,an_edge.edge_start)) == oriented_edge(an_edge,FALSE) + return the_reverse + +#################### + # FUNCTION default_tolerance_table_cell_wr5 # +#################### +def default_tolerance_table_cell_wr5(agg,): + ''' + :param agg + :type agg:(null) + ''' + if ((SIZEOF(None) <= 1) and (SIZEOF(None) == SIZEOF(None))): + return TRUE + else: + return FALSE + +#################### + # FUNCTION constraints_composite_curve_on_surface # +#################### +def constraints_composite_curve_on_surface(c,): + ''' + :param c + :type c:composite_curve_on_surface + ''' + for k in range(1,n_segments,1): + if ((( not ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(c.composite_curve.segments[k].parent_curve))) and ( not ('AUTOMOTIVE_DESIGN.SURFACE_CURVE' == TYPEOF(c.composite_curve.segments[k].parent_curve)))) and ( not ('AUTOMOTIVE_DESIGN.COMPOSITE_CURVE_ON_SURFACE' == TYPEOF(c.composite_curve.segments[k].parent_curve)))): + return FALSE + return TRUE + +#################### + # FUNCTION default_tolerance_table_cell_wr4 # +#################### +def default_tolerance_table_cell_wr4(agg,): + ''' + :param agg + :type agg:(null) + ''' + if ((SIZEOF(None) == 1) or ((SIZEOF(None) == 1) and (SIZEOF(None) == 1))): + return TRUE + else: + return FALSE + +#################### + # FUNCTION acyclic_mapped_representation # +#################### +def acyclic_mapped_representation(parent_set,children_set,): + ''' + :param parent_set + :type parent_set:(null) + :param children_set + :type children_set:(null) + ''' + x = None + if (SIZEOF(x) > 0): + for i in range(1,HIINDEX(x),1): + if (x[i].mapped_item.mapping_source.mapped_representation == parent_set): + return FALSE + if ( not acyclic_mapped_representation(parent_set + x[i].mapped_item.mapping_source.mapped_representation,x[i].mapped_item.mapping_source.mapped_representation.items)): + return FALSE + x = children_set - x + if (SIZEOF(x) > 0): + for i in range(1,HIINDEX(x),1): + y = None + if ( not acyclic_mapped_representation(parent_set,y)): + return FALSE + return TRUE + +#################### + # FUNCTION get_name_value # +#################### +def get_name_value(obj,): + ''' + :param obj + :type obj:name_attribute_select + ''' + if (SIZEOF(name_bag) == 1): + return name_bag[1].attribute_value + else: + return None + +#################### + # FUNCTION convert_spatial_to_ypr_rotation # +#################### +def convert_spatial_to_ypr_rotation(pair,rotation,): + ''' + :param pair + :type pair:kinematic_pair + :param rotation + :type rotation:spatial_rotation + ''' + if ('AUTOMOTIVE_DESIGN.YPR_ROTATION' == TYPEOF(rotation)): + return rotation + axis = normalise(rotation.rotation_about_direction.direction_of_axis) + angle = rotation.rotation_about_direction.rotation_angle + if (angle == 0): + return [0,0,0] + dx = axis.direction_ratios[1] + dy = axis.direction_ratios[2] + dz = axis.direction_ratios[3] + conv_angle = plane_angle_for_pair_in_radian(pair,angle) + if (conv_angle == None ): + return None + ucf = angle / conv_angle + s_a = SIN(conv_angle) + c_a = COS(conv_angle) + if ((dy == 0) and ((dx * dz) == 0)): + for while conv_angle <= (- PI ) conv_angle = conv_angle + (2 * PI ) + for while conv_angle > PI conv_angle = conv_angle - (2 * PI ) + ya = ucf * conv_angle + if (conv_angle != PI ): + ra = -ya + else: + ra = ya + if (dx != 0): + if (dx > 0): + return [0,0,ya] + else: + return [0,0,ra] + else: + if (dz > 0): + return [ya,0,0] + else: + return [ra,0,0] + if (((dy != 0) and (dx == 0)) and (dz == 0)): + if (c_a >= 0): + ya = 0 + ra = 0 + else: + ya = ucf * PI + ra = ya + pa = ucf * ATAN(s_a,ABS(c_a)) + if (dy < 0): + pa = -pa + return [ya,pa,ra] + cm1 = 1 - c_a + rotmat = [[((dx * dx) * cm1) + c_a,((dx * dy) * cm1) - (dz * s_a),((dx * dz) * cm1) + (dy * s_a)],[((dx * dy) * cm1) + (dz * s_a),((dy * dy) * cm1) + c_a,((dy * dz) * cm1) - (dx * s_a)],[((dx * dz) * cm1) - (dy * s_a),((dy * dz) * cm1) + (dx * s_a),((dz * dz) * cm1) + c_a]] + if (ABS(rotmat[1][3]) == 1): + if (rotmat[1][3] == 1): + pa = 0.5 * PI + else: + pa = (-0.5) * PI + ra = 0 + ya = ATAN(rotmat[2][1],rotmat[2][2]) + if (rotmat[2][2] < 0): + if (ya <= 0): + ya = ya + PI + else: + ya = ya - PI + else: + ya = ATAN(-rotmat[1][2],rotmat[1][1]) + if (rotmat[1][1] < 0): + if (ya <= 0): + ya = ya + PI + else: + ya = ya - PI + ra = ATAN(-rotmat[2][3],rotmat[3][3]) + if (rotmat[3][3] < 0): + if (ra <= 0): + ra = ra + PI + else: + ra = ra - PI + s_y = SIN(ya) + c_y = COS(ya) + s_r = SIN(ra) + c_r = COS(ra) + if (((ABS(s_y) > ABS(c_y)) and (ABS(s_y) > ABS(s_r))) and (ABS(s_y) > ABS(c_r))): + cm1 = (-rotmat[1][2]) / s_y + else: + if ((ABS(c_y) > ABS(s_r)) and (ABS(c_y) > ABS(c_r))): + cm1 = rotmat[1][1] / c_y + else: + if (ABS(s_r) > ABS(c_r)): + cm1 = (-rotmat[2][3]) / s_r + else: + cm1 = rotmat[3][3] / c_r + pa = ATAN(rotmat[1][3],cm1) + ya = ya * ucf + pa = pa * ucf + ra = ra * ucf + return [ya,pa,ra] + +#################### + # FUNCTION check_text_font # +#################### +def check_text_font(ct,): + ''' + :param ct + :type ct:composite_text + ''' + for i in range(1,HIINDEX(ct.collected_text),1): + f = f + [ct.collected_text[i].text_literal.font] + return SIZEOF(f) <= 1 + +#################### + # FUNCTION conditional_reverse # +#################### +def conditional_reverse(p,an_item,): + ''' + :param p + :type p:BOOLEAN + :param an_item + :type an_item:reversible_topology + ''' + if (p): + return an_item + else: + return topology_reversed(an_item) + +#################### + # FUNCTION nmsf_curve_check # +#################### +def nmsf_curve_check(cv,): + ''' + :param cv + :type cv:representation_item + ''' + if (SIZEOF(['AUTOMOTIVE_DESIGN.BOUNDED_CURVE','AUTOMOTIVE_DESIGN.CONIC','AUTOMOTIVE_DESIGN.CURVE_REPLICA','AUTOMOTIVE_DESIGN.LINE','AUTOMOTIVE_DESIGN.OFFSET_CURVE_3D'] * TYPEOF(cv)) > 1): + return FALSE + else: + if ((('AUTOMOTIVE_DESIGN.B_SPLINE_CURVE' == TYPEOF(cv)) and (cv.b_spline_curve.self_intersect == FALSE)) or (cv.b_spline_curve.self_intersect == UNKNOWN)): + return TRUE + else: + if (SIZEOF(['AUTOMOTIVE_DESIGN.CONIC','AUTOMOTIVE_DESIGN.LINE'] * TYPEOF(cv)) == 1): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.CURVE_REPLICA' == TYPEOF(cv)): + return nmsf_curve_check(cv.curve_replica.parent_curve) + else: + if ((('AUTOMOTIVE_DESIGN.OFFSET_CURVE_3D' == TYPEOF(cv)) and ((cv.offset_curve_3d.self_intersect == FALSE) or (cv.offset_curve_3d.self_intersect == UNKNOWN))) and ( not ('AUTOMOTIVE_DESIGN.POLYLINE' == TYPEOF(cv.offset_curve_3d.basis_curve)))): + return nmsf_curve_check(cv.offset_curve_3d.basis_curve) + else: + if ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(cv)): + return nmsf_curve_check(cv.pcurve.reference_to_curve.representation.items[1]) and nmsf_surface_check(cv.pcurve.basis_surface) + else: + if ('AUTOMOTIVE_DESIGN.SURFACE_CURVE' == TYPEOF(cv)): + if (nmsf_curve_check(cv.surface_curve.curve_3d)): + for i in range(1,SIZEOF(cv.surface_curve.associated_geometry),1): + if ('AUTOMOTIVE_DESIGN.SURFACE' == TYPEOF(cv.surface_curve.associated_geometry[i])): + if ( not nmsf_surface_check(cv.surface_curve.associated_geometry[i])): + return FALSE + else: + if ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(cv.surface_curve.associated_geometry[i])): + if ( not nmsf_curve_check(cv.surface_curve.associated_geometry[i])): + return FALSE + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.POLYLINE' == TYPEOF(cv)): + if (SIZEOF(cv.polyline.points) >= 3): + return TRUE + return FALSE + +#################### + # FUNCTION valid_measure_value # +#################### +def valid_measure_value(m,): + ''' + :param m + :type m:measure_value + ''' + if ('REAL' == TYPEOF(m)): + return m > 0 + else: + if ('INTEGER' == TYPEOF(m)): + return m > 0 + else: + return TRUE + +#################### + # FUNCTION gbsf_check_curve # +#################### +def gbsf_check_curve(cv,): + ''' + :param cv + :type cv:representation_item + ''' + if (SIZEOF(['AUTOMOTIVE_DESIGN.BOUNDED_CURVE','AUTOMOTIVE_DESIGN.CONIC','AUTOMOTIVE_DESIGN.CURVE_REPLICA','AUTOMOTIVE_DESIGN.LINE','AUTOMOTIVE_DESIGN.OFFSET_CURVE_3D'] * TYPEOF(cv)) > 1): + return FALSE + if (SIZEOF(['AUTOMOTIVE_DESIGN.CIRCLE','AUTOMOTIVE_DESIGN.ELLIPSE','AUTOMOTIVE_DESIGN.TRIMMED_CURVE'] * TYPEOF(cv)) == 1): + return TRUE + else: + if ((('AUTOMOTIVE_DESIGN.B_SPLINE_CURVE' == TYPEOF(cv)) and (cv.b_spline_curve.self_intersect == FALSE)) or (cv.b_spline_curve.self_intersect == UNKNOWN)): + return TRUE + else: + if ((('AUTOMOTIVE_DESIGN.COMPOSITE_CURVE' == TYPEOF(cv)) and (cv.composite_curve.self_intersect == FALSE)) or (cv.composite_curve.self_intersect == UNKNOWN)): + return SIZEOF(None) == 0 + else: + if ('AUTOMOTIVE_DESIGN.CURVE_REPLICA' == TYPEOF(cv)): + return gbsf_check_curve(cv.curve_replica.parent_curve) + else: + if ((('AUTOMOTIVE_DESIGN.OFFSET_CURVE_3D' == TYPEOF(cv)) and ((cv.offset_curve_3d.self_intersect == FALSE) or (cv.offset_curve_3d.self_intersect == UNKNOWN))) and ( not ('AUTOMOTIVE_DESIGN.POLYLINE' == TYPEOF(cv.offset_curve_3d.basis_curve)))): + return gbsf_check_curve(cv.offset_curve_3d.basis_curve) + else: + if ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(cv)): + return gbsf_check_curve(cv.pcurve.reference_to_curve.representation.items[1]) and gbsf_check_surface(cv.pcurve.basis_surface) + else: + if ('AUTOMOTIVE_DESIGN.POLYLINE' == TYPEOF(cv)): + if (SIZEOF(cv.polyline.points) >= 3): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.SURFACE_CURVE' == TYPEOF(cv)): + if (gbsf_check_curve(cv.surface_curve.curve_3d)): + for i in range(1,SIZEOF(cv.surface_curve.associated_geometry),1): + if ('AUTOMOTIVE_DESIGN.SURFACE' == TYPEOF(cv.surface_curve.associated_geometry[i])): + if ( not gbsf_check_surface(cv.surface_curve.associated_geometry[i])): + return FALSE + else: + if ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(cv.surface_curve.associated_geometry[i])): + if ( not gbsf_check_curve(cv.surface_curve.associated_geometry[i])): + return FALSE + return TRUE + return FALSE + +#################### + # FUNCTION base_axis # +#################### +def base_axis(dim,axis1,axis2,axis3,): + ''' + :param dim + :type dim:INTEGER + :param axis1 + :type axis1:direction + :param axis2 + :type axis2:direction + :param axis3 + :type axis3:direction + ''' + if (dim == 3): + d1 = NVL(normalise(axis3),dummy_gri == direction([0,0,1])) + d2 = first_proj_axis(d1,axis1) + u = [d2,second_proj_axis(d1,d2,axis2),d1] + else: + if (EXISTS(axis1)): + d1 = normalise(axis1) + u = [d1,orthogonal_complement(d1)] + if (EXISTS(axis2)): + factor = dot_product(axis2,u[2]) + if (factor < 0): + u[2].direction_ratios[1] = -u[2].direction_ratios[1] + u[2].direction_ratios[2] = -u[2].direction_ratios[2] + else: + if (EXISTS(axis2)): + d1 = normalise(axis2) + u = [orthogonal_complement(d1),d1] + u[1].direction_ratios[1] = -u[1].direction_ratios[1] + u[1].direction_ratios[2] = -u[1].direction_ratios[2] + else: + u = [dummy_gri == direction([1,0]),dummy_gri == direction([0,1])] + return u + +#################### + # FUNCTION get_basis_surface # +#################### +def get_basis_surface(c,): + ''' + :param c + :type c:curve_on_surface + ''' + surfs = [] + if ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(c)): + surfs = [c.pcurve.basis_surface] + else: + if ('AUTOMOTIVE_DESIGN.SURFACE_CURVE' == TYPEOF(c)): + n = SIZEOF(c.surface_curve.associated_geometry) + for i in range(1,n,1): + surfs = surfs + associated_surface(c.surface_curve.associated_geometry[i]) + if ('AUTOMOTIVE_DESIGN.COMPOSITE_CURVE_ON_SURFACE' == TYPEOF(c)): + n = SIZEOF(c.composite_curve.segments) + surfs = get_basis_surface(c.composite_curve.segments[1].parent_curve) + if (n > 1): + for i in range(2,n,1): + surfs = surfs * get_basis_surface(c.composite_curve.segments[i].parent_curve) + return surfs + +#################### + # FUNCTION coordinated_pair_link_representation # +#################### +def coordinated_pair_link_representation(link,pair_placement,): + ''' + :param link + :type link:kinematic_link + :param pair_placement + :type pair_placement:rigid_placement + ''' + link_rep = representation_of_link(link) + if (link_rep == None ): + return FALSE + else: + if ( not (pair_placement == link_rep.representation.items)): + return FALSE + else: + return TRUE + +#################### + # FUNCTION list_face_loops # +#################### +def list_face_loops(f,): + ''' + :param f + :type f:face + ''' + for i in range(1,SIZEOF(f.bounds),1): + loops = loops + f.bounds[i].bound + return loops + +#################### + # FUNCTION get_diameter_for_round_hole # +#################### +def get_diameter_for_round_hole(rh,): + ''' + :param rh + :type rh:round_hole + ''' + sa_set = get_shape_aspects(rh) + for i in range(1,HIINDEX(sa_set),1): + if (sa_set[i].description == 'diameter occurrence'): + sar_set = bag_to_set(USEDIN(sa_set[i],'AUTOMOTIVE_DESIGN.SHAPE_ASPECT_RELATIONSHIP.RELATED_SHAPE_ASPECT')) + for j in range(1,HIINDEX(sar_set),1): + if ((((sar_set[j].name == 'diameter') and (sar_set[j].description == 'profile usage')) and ('AUTOMOTIVE_DESIGN.SHAPE_DEFINING_RELATIONSHIP' == TYPEOF(sar_set[j]))) and ('AUTOMOTIVE_DESIGN.CIRCULAR_CLOSED_PROFILE' == TYPEOF(sar_set[j].relating_shape_aspect))): + pdr_set = get_shape_aspect_property_definition_representations(sar_set[j].relating_shape_aspect) + for k in range(1,HIINDEX(pdr_set),1): + if ('AUTOMOTIVE_DESIGN.SHAPE_REPRESENTATION_WITH_PARAMETERS' == TYPEOF(pdr_set[k].used_representation)): + ri_set = pdr_set[k].used_representation.items + for l in range(1,HIINDEX(ri_set),1): + if (('AUTOMOTIVE_DESIGN.MEASURE_REPRESENTATION_ITEM' == TYPEOF(ri_set[l])) and ('AUTOMOTIVE_DESIGN.LENGTH_MEASURE_WITH_UNIT' == TYPEOF(ri_set[l]))): + return ri_set[l].measure_with_unit.value_component + return None + +#################### + # FUNCTION list_of_topology_reversed # +#################### +def list_of_topology_reversed(a_list,): + ''' + :param a_list + :type a_list:list_of_reversible_topology_item + ''' + the_reverse = [] + for i in range(1,SIZEOF(a_list),1): + the_reverse = topology_reversed(a_list[i]) + the_reverse + return the_reverse + +#################### + # FUNCTION msf_curve_check # +#################### +def msf_curve_check(cv,): + ''' + :param cv + :type cv:representation_item + ''' + if (SIZEOF(['AUTOMOTIVE_DESIGN.BOUNDED_CURVE','AUTOMOTIVE_DESIGN.CONIC','AUTOMOTIVE_DESIGN.CURVE_REPLICA','AUTOMOTIVE_DESIGN.LINE','AUTOMOTIVE_DESIGN.OFFSET_CURVE_3D'] * TYPEOF(cv)) > 1): + return FALSE + if ((('AUTOMOTIVE_DESIGN.B_SPLINE_CURVE' == TYPEOF(cv)) and (cv.b_spline_curve.self_intersect == FALSE)) or (cv.b_spline_curve.self_intersect == UNKNOWN)): + return TRUE + else: + if (SIZEOF(['AUTOMOTIVE_DESIGN.CONIC','AUTOMOTIVE_DESIGN.LINE'] * TYPEOF(cv)) == 1): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.CURVE_REPLICA' == TYPEOF(cv)): + return msf_curve_check(cv.curve_replica.parent_curve) + else: + if ((('AUTOMOTIVE_DESIGN.OFFSET_CURVE_3D' == TYPEOF(cv)) and ((cv.offset_curve_3d.self_intersect == FALSE) or (cv.offset_curve_3d.self_intersect == UNKNOWN))) and ( not ('AUTOMOTIVE_DESIGN.POLYLINE' == TYPEOF(cv.offset_curve_3d.basis_curve)))): + return msf_curve_check(cv.offset_curve_3d.basis_curve) + else: + if ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(cv)): + return msf_curve_check(cv.pcurve.reference_to_curve.representation.items[1]) and msf_surface_check(cv.pcurve.basis_surface) + else: + if ('AUTOMOTIVE_DESIGN.SURFACE_CURVE' == TYPEOF(cv)): + if (msf_curve_check(cv.surface_curve.curve_3d)): + for i in range(1,SIZEOF(cv.surface_curve.associated_geometry),1): + if ('AUTOMOTIVE_DESIGN.SURFACE' == TYPEOF(cv.surface_curve.associated_geometry[i])): + if ( not msf_surface_check(cv.surface_curve.associated_geometry[i])): + return FALSE + else: + if ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(cv.surface_curve.associated_geometry[i])): + if ( not msf_curve_check(cv.surface_curve.associated_geometry[i])): + return FALSE + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.POLYLINE' == TYPEOF(cv)): + if (SIZEOF(cv.polyline.points) >= 3): + return TRUE + return FALSE + +#################### + # FUNCTION shell_reversed # +#################### +def shell_reversed(a_shell,): + ''' + :param a_shell + :type a_shell:shell + ''' + if ('AUTOMOTIVE_DESIGN.OPEN_SHELL' == TYPEOF(a_shell)): + return open_shell_reversed(a_shell) + else: + if ('AUTOMOTIVE_DESIGN.CLOSED_SHELL' == TYPEOF(a_shell)): + return closed_shell_reversed(a_shell) + else: + return None + +#################### + # FUNCTION topology_reversed # +#################### +def topology_reversed(an_item,): + ''' + :param an_item + :type an_item:reversible_topology + ''' + if ('AUTOMOTIVE_DESIGN.EDGE' == TYPEOF(an_item)): + return edge_reversed(an_item) + if ('AUTOMOTIVE_DESIGN.PATH' == TYPEOF(an_item)): + return path_reversed(an_item) + if ('AUTOMOTIVE_DESIGN.FACE_BOUND' == TYPEOF(an_item)): + return face_bound_reversed(an_item) + if ('AUTOMOTIVE_DESIGN.FACE' == TYPEOF(an_item)): + return face_reversed(an_item) + if ('AUTOMOTIVE_DESIGN.SHELL' == TYPEOF(an_item)): + return shell_reversed(an_item) + if ('SET' == TYPEOF(an_item)): + return set_of_topology_reversed(an_item) + if ('LIST' == TYPEOF(an_item)): + return list_of_topology_reversed(an_item) + return None + +#################### + # FUNCTION first_proj_axis # +#################### +def first_proj_axis(z_axis,arg,): + ''' + :param z_axis + :type z_axis:direction + :param arg + :type arg:direction + ''' + if ( not EXISTS(z_axis)): + return None + else: + z = normalise(z_axis) + if ( not EXISTS(arg)): + if ((z.direction_ratios != [1,0,0]) and (z.direction_ratios != [-1,0,0])): + v = dummy_gri == direction([1,0,0]) + else: + v = dummy_gri == direction([0,1,0]) + else: + if (arg.dim != 3): + return None + if (cross_product(arg,z).magnitude == 0): + return None + else: + v = normalise(arg) + x_vec = scalar_times_vector(dot_product(v,z),z) + x_axis = vector_difference(v,x_vec).orientation + x_axis = normalise(x_axis) + return x_axis + +#################### + # FUNCTION acyclic_composite_text # +#################### +def acyclic_composite_text(start_composite,child_text,): + ''' + :param start_composite + :type start_composite:composite_text + :param child_text + :type child_text:(null) + ''' + local_composite_text = None + if (SIZEOF(local_composite_text) > 0): + for i in range(1,HIINDEX(local_composite_text),1): + if (start_composite == local_composite_text[i]): + return FALSE + local_children = child_text + if (SIZEOF(local_composite_text) > 0): + for i in range(1,HIINDEX(local_composite_text),1): + local_children = local_children + local_composite_text[i].collected_text + local_annotation_text = None + if (SIZEOF(local_annotation_text) > 0): + for i in range(1,HIINDEX(local_annotation_text),1): + local_children = local_children + None + if (local_children != child_text): + return acyclic_composite_text(start_composite,local_children) + else: + return TRUE + +#################### + # FUNCTION get_shape_aspect_property_definition_representations # +#################### +def get_shape_aspect_property_definition_representations(s_a_instance,): + ''' + :param s_a_instance + :type s_a_instance:shape_aspect + ''' + pd_set = bag_to_set(USEDIN(s_a_instance,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION.DEFINITION')) + if (SIZEOF(pd_set) < 1): + return pdr_set + for i in range(1,HIINDEX(pd_set),1): + pdr_set = pdr_set + None + return pdr_set + +#################### + # FUNCTION orthogonal_complement # +#################### +def orthogonal_complement(vec,): + ''' + :param vec + :type vec:direction + ''' + if ((vec.dim != 2) or ( not EXISTS(vec))): + return None + else: + result = dummy_gri == direction([-vec.direction_ratios[2],vec.direction_ratios[1]]) + return result + +#################### + # FUNCTION get_shape_aspects # +#################### +def get_shape_aspects(c_def_instance,): + ''' + :param c_def_instance + :type c_def_instance:characterized_definition + ''' + pd_set = bag_to_set(None) + if (SIZEOF(pd_set) < 1): + return pdr_set + for i in range(1,HIINDEX(pd_set),1): + pdr_set = pdr_set + bag_to_set(USEDIN(pd_set[i],'AUTOMOTIVE_DESIGN.SHAPE_ASPECT.OF_SHAPE')) + return pdr_set + +#################### + # FUNCTION make_array_of_array # +#################### +def make_array_of_array(lis,low1,u1,low2,u2,): + ''' + :param lis + :type lis:(null) + :param low1 + :type low1:INTEGER + :param u1 + :type u1:INTEGER + :param low2 + :type low2:INTEGER + :param u2 + :type u2:INTEGER + ''' + if (((u1 - low1) + 1) != SIZEOF(lis)): + return None + if (((u2 - low2) + 1) != SIZEOF(lis[1])): + return None + res = [list_to_array(lis[1],low2,u2),(u1 - low1) + 1] + for i in range(2,HIINDEX(lis),1): + if (((u2 - low2) + 1) != SIZEOF(lis[i])): + return None + res[(low1 + i) - 1] = list_to_array(lis[i],low2,u2) + return res + +#################### + # FUNCTION second_proj_axis # +#################### +def second_proj_axis(z_axis,x_axis,arg,): + ''' + :param z_axis + :type z_axis:direction + :param x_axis + :type x_axis:direction + :param arg + :type arg:direction + ''' + if ( not EXISTS(arg)): + v = dummy_gri == direction([0,1,0]) + else: + v = arg + temp = scalar_times_vector(dot_product(v,z_axis),z_axis) + y_axis = vector_difference(v,temp) + temp = scalar_times_vector(dot_product(v,x_axis),x_axis) + y_axis = vector_difference(y_axis,temp) + y_axis = normalise(y_axis) + return y_axis.orientation + +#################### + # FUNCTION bag_to_set # +#################### +def bag_to_set(the_bag,): + ''' + :param the_bag + :type the_bag:(null) + ''' + if (SIZEOF(the_bag) > 0): + for i in range(1,HIINDEX(the_bag),1): + the_set = the_set + the_bag[i] + return the_set + +#################### + # FUNCTION valid_wireframe_edge_curve # +#################### +def valid_wireframe_edge_curve(crv,): + ''' + :param crv + :type crv:curve + ''' + if (SIZEOF(['AUTOMOTIVE_DESIGN.LINE','AUTOMOTIVE_DESIGN.CONIC','AUTOMOTIVE_DESIGN.B_SPLINE_CURVE','AUTOMOTIVE_DESIGN.POLYLINE'] * TYPEOF(crv)) == 1): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.CURVE_REPLICA' == TYPEOF(crv)): + return valid_wireframe_edge_curve(crv.curve_replica.parent_curve) + else: + if ('AUTOMOTIVE_DESIGN.OFFSET_CURVE_3D' == TYPEOF(crv)): + return valid_wireframe_edge_curve(crv.offset_curve_3d.basis_curve) + return FALSE + +#################### + # FUNCTION acyclic_product_category_relationship # +#################### +def acyclic_product_category_relationship(relation,children,): + ''' + :param relation + :type relation:product_category_relationship + :param children + :type children:(null) + ''' + for i in range(1,HIINDEX(children),1): + if (relation.category == children[i]): + return FALSE + x = bag_to_set(USEDIN(relation.category,'AUTOMOTIVE_DESIGN.PRODUCT_CATEGORY_RELATIONSHIP.SUB_CATEGORY')) + local_children = children + relation.category + if (SIZEOF(x) > 0): + for i in range(1,HIINDEX(x),1): + if ( not acyclic_product_category_relationship(x[i],local_children)): + return FALSE + return TRUE + +#################### + # FUNCTION surface_weights_positive # +#################### +def surface_weights_positive(b,): + ''' + :param b + :type b:rational_b_spline_surface + ''' + for i in range(0,b.u_upper,1): + for j in range(0,b.v_upper,1): + if (b.weights[i][j] <= 0): + result = FALSE + return result + return result + +#################### + # FUNCTION vector_difference # +#################### +def vector_difference(arg1,arg2,): + ''' + :param arg1 + :type arg1:vector_or_direction + :param arg2 + :type arg2:vector_or_direction + ''' + if ((( not EXISTS(arg1)) or ( not EXISTS(arg2))) or (arg1.dim != arg2.dim)): + return None + else: + if ('AUTOMOTIVE_DESIGN.VECTOR' == TYPEOF(arg1)): + mag1 = arg1.magnitude + vec1 = arg1.vector.orientation + else: + mag1 = 1 + vec1 = arg1 + if ('AUTOMOTIVE_DESIGN.VECTOR' == TYPEOF(arg2)): + mag2 = arg2.magnitude + vec2 = arg2.vector.orientation + else: + mag2 = 1 + vec2 = arg2 + vec1 = normalise(vec1) + vec2 = normalise(vec2) + ndim = SIZEOF(vec1.direction_ratios) + mag = 0 + res = dummy_gri == direction(vec1.direction_ratios) + for i in range(1,ndim,1): + res.direction_ratios[i] = (mag1 * vec1.direction_ratios[i]) - (mag2 * vec2.direction_ratios[i]) + mag = mag + (res.direction_ratios[i] * res.direction_ratios[i]) + if (mag > 0): + result = dummy_gri == vector(res,SQRT(mag)) + else: + result = dummy_gri == vector(vec1,0) + return result + +#################### + # FUNCTION advanced_face_properties # +#################### +def advanced_face_properties(testface,): + ''' + :param testface + :type testface:face + ''' + if ('AUTOMOTIVE_DESIGN.ADVANCED_FACE' == TYPEOF(testface)): + return TRUE + if ('AUTOMOTIVE_DESIGN.SUBFACE' == TYPEOF(testface)): + return advanced_face_properties(testface.parent_face) + else: + return FALSE + +#################### + # FUNCTION get_property_definition_representations # +#################### +def get_property_definition_representations(c_def_instance,): + ''' + :param c_def_instance + :type c_def_instance:characterized_definition + ''' + pd_set = bag_to_set(USEDIN(c_def_instance,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION.DEFINITION')) + if (SIZEOF(pd_set) < 1): + return pdr_set + for i in range(1,HIINDEX(pd_set),1): + pdr_set = pdr_set + bag_to_set(USEDIN(pd_set[i],'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')) + return pdr_set + +#################### + # FUNCTION value_range_wr1 # +#################### +def value_range_wr1(agg,): + ''' + :param agg + :type agg:(null) + ''' + if ((SIZEOF(agg) == 2) and ((SIZEOF(None) == 2) or (SIZEOF(None) == 2))): + return TRUE + else: + return FALSE + +#################### + # FUNCTION value_range_wr3 # +#################### +def value_range_wr3(agg,): + ''' + :param agg + :type agg:(null) + ''' + if (SIZEOF(None) == 2): + return TRUE + else: + return FALSE + +#################### + # FUNCTION acyclic_product_definition_relationship # +#################### +def acyclic_product_definition_relationship(relation,relatives,specific_relation,): + ''' + :param relation + :type relation:product_definition_relationship + :param relatives + :type relatives:(null) + :param specific_relation + :type specific_relation:STRING + ''' + if (relation.relating_product_definition == relatives): + return FALSE + x = None + for i in range(1,HIINDEX(x),1): + if ( not acyclic_product_definition_relationship(x[i],relatives + relation.relating_product_definition,specific_relation)): + return FALSE + return TRUE + +#################### + # FUNCTION value_range_wr2 # +#################### +def value_range_wr2(agg,): + ''' + :param agg + :type agg:(null) + ''' + if ((SIZEOF(None) == 1) and (SIZEOF(None) == 1)): + return TRUE + else: + return FALSE + +#################### + # FUNCTION list_to_set # +#################### +def list_to_set(l,): + ''' + :param l + :type l:(null) + ''' + for i in range(1,SIZEOF(l),1): + s = s + l[i] + return s + +#################### + # FUNCTION valid_calendar_date # +#################### +def valid_calendar_date(date,): + ''' + :param date + :type date:calendar_date + ''' + case_selector = date.month_component + if case_selector == 1: + return (1 <= date.day_component) and (date.day_component <= 31) + elif case_selector == 2: + # begin/end block + if (leap_year(date.year_component)): + return (1 <= date.day_component) and (date.day_component <= 29) + else: + return (1 <= date.day_component) and (date.day_component <= 28) + elif case_selector == 3: + return (1 <= date.day_component) and (date.day_component <= 31) + elif case_selector == 4: + return (1 <= date.day_component) and (date.day_component <= 30) + elif case_selector == 5: + return (1 <= date.day_component) and (date.day_component <= 31) + elif case_selector == 6: + return (1 <= date.day_component) and (date.day_component <= 30) + elif case_selector == 7: + return (1 <= date.day_component) and (date.day_component <= 31) + elif case_selector == 8: + return (1 <= date.day_component) and (date.day_component <= 31) + elif case_selector == 9: + return (1 <= date.day_component) and (date.day_component <= 30) + elif case_selector == 10: + return (1 <= date.day_component) and (date.day_component <= 31) + elif case_selector == 11: + return (1 <= date.day_component) and (date.day_component <= 30) + elif case_selector == 12: + return (1 <= date.day_component) and (date.day_component <= 31) + return FALSE + +#################### + # FUNCTION valid_wireframe_vertex_point # +#################### +def valid_wireframe_vertex_point(pnt,): + ''' + :param pnt + :type pnt:point + ''' + if ('AUTOMOTIVE_DESIGN.CARTESIAN_POINT' == TYPEOF(pnt)): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.POINT_REPLICA' == TYPEOF(pnt)): + return valid_wireframe_vertex_point(pnt.point_replica.parent_pt) + return FALSE + +#################### + # FUNCTION list_to_array # +#################### +def list_to_array(lis,low,u,): + ''' + :param lis + :type lis:(null) + :param low + :type low:INTEGER + :param u + :type u:INTEGER + ''' + n = SIZEOF(lis) + if (n != ((u - low) + 1)): + return None + else: + res = [lis[1],n] + for i in range(2,n,1): + res[(low + i) - 1] = lis[i] + return res + +#################### + # FUNCTION using_items # +#################### +def using_items(item,checked_items,): + ''' + :param item + :type item:founded_item_select + :param checked_items + :type checked_items:(null) + ''' + result_items = [] + new_check_items = checked_items + item + next_items = None + if (SIZEOF(next_items) > 0): + for i in range(1,HIINDEX(next_items),1): + if ( not (next_items[i] == new_check_items)): + result_items = (result_items + next_items[i]) + using_items(next_items[i],new_check_items) + return result_items + +#################### + # FUNCTION valid_basis_curve_in_2d_wireframe # +#################### +def valid_basis_curve_in_2d_wireframe(crv,): + ''' + :param crv + :type crv:curve + ''' + if (SIZEOF(['AUTOMOTIVE_DESIGN.POLYLINE','AUTOMOTIVE_DESIGN.B_SPLINE_CURVE','AUTOMOTIVE_DESIGN.ELLIPSE','AUTOMOTIVE_DESIGN.CIRCLE'] * TYPEOF(crv)) == 1): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.TRIMMED_CURVE' == TYPEOF(crv)): + if (SIZEOF(['AUTOMOTIVE_DESIGN.LINE','AUTOMOTIVE_DESIGN.PARABOLA','AUTOMOTIVE_DESIGN.HYPERBOLA'] * TYPEOF(crv.trimmed_curve.basis_curve)) == 1): + return TRUE + else: + return valid_basis_curve_in_2d_wireframe(crv.trimmed_curve.basis_curve) + else: + if ('AUTOMOTIVE_DESIGN.OFFSET_CURVE_2D' == TYPEOF(crv)): + return valid_basis_curve_in_2d_wireframe(crv.offset_curve_2d.basis_curve) + else: + if ('AUTOMOTIVE_DESIGN.CURVE_REPLICA' == TYPEOF(crv)): + return valid_basis_curve_in_2d_wireframe(crv.curve_replica.parent_curve) + else: + if ('AUTOMOTIVE_DESIGN.COMPOSITE_CURVE' == TYPEOF(crv)): + return SIZEOF(None) == 0 + return FALSE + +#################### + # FUNCTION constraints_geometry_shell_based_surface_model # +#################### +def constraints_geometry_shell_based_surface_model(m,): + ''' + :param m + :type m:shell_based_surface_model + ''' + for j in range(1,SIZEOF(m.sbsm_boundary),1): + if (( not ('AUTOMOTIVE_DESIGN.OPEN_SHELL' == TYPEOF(m.sbsm_boundary[j]))) and ( not ('AUTOMOTIVE_DESIGN.CLOSED_SHELL' == TYPEOF(m.sbsm_boundary[j])))): + result = FALSE + return result + return result + +#################### + # FUNCTION face_bound_reversed # +#################### +def face_bound_reversed(a_face_bound,): + ''' + :param a_face_bound + :type a_face_bound:face_bound + ''' + if ('AUTOMOTIVE_DESIGN.FACE_OUTER_BOUND' == TYPEOF(a_face_bound)): + the_reverse = (dummy_tri == face_bound(a_face_bound.face_bound.bound, not a_face_bound.face_bound.orientation)) == face_outer_bound() + else: + the_reverse = dummy_tri == face_bound(a_face_bound.bound, not a_face_bound.orientation) + return the_reverse + +#################### + # FUNCTION acyclic # +#################### +def acyclic(arg1,arg2,): + ''' + :param arg1 + :type arg1:generic_expression + :param arg2 + :type arg2:(null) + ''' + if ('AUTOMOTIVE_DESIGN.SIMPLE_GENERIC_EXPRESSION' == TYPEOF(arg1)): + return TRUE + if (arg1 == arg2): + return FALSE + if ('AUTOMOTIVE_DESIGN.UNARY_GENERIC_EXPRESSION' == TYPEOF(arg1)): + return acyclic(arg1.unary_generic_expression.operand,arg2 + [arg1]) + if ('AUTOMOTIVE_DESIGN.BINARY_GENERIC_EXPRESSION' == TYPEOF(arg1)): + return acyclic(arg1.binary_generic_expression.operands[1],arg2 + [arg1]) and acyclic(arg1.binary_generic_expression.operands[2],arg2 + [arg1]) + if ('AUTOMOTIVE_DESIGN.MULTIPLE_ARITY_GENERIC_EXPRESSION' == TYPEOF(arg1)): + result = TRUE + for i in range(1,SIZEOF(arg1.multiple_arity_generic_expression.operands),1): + result = result and acyclic(arg1.multiple_arity_generic_expression.operands[i],arg2 + [arg1]) + return result + +#################### + # FUNCTION set_of_topology_reversed # +#################### +def set_of_topology_reversed(a_set,): + ''' + :param a_set + :type a_set:set_of_reversible_topology_item + ''' + the_reverse = [] + for i in range(1,SIZEOF(a_set),1): + the_reverse = the_reverse + topology_reversed(a_set[i]) + return the_reverse + +#################### + # FUNCTION item_correlation # +#################### +def item_correlation(items,c_items,): + ''' + :param items + :type items:(null) + :param c_items + :type c_items:(null) + ''' + for i in range(1,HIINDEX(c_items),1): + c_types = c_types + ['AUTOMOTIVE_DESIGN.' + c_items[i]] + for i in range(1,HIINDEX(items),1): + if (SIZEOF(c_types * TYPEOF(items[i])) == 1): + c_hit = c_hit + 1 + if (SIZEOF(items) == c_hit): + return TRUE + else: + return FALSE + +#################### + # FUNCTION is_int_expr # +#################### +def is_int_expr(arg,): + ''' + :param arg + :type arg:numeric_expression + ''' + if ('AUTOMOTIVE_DESIGN.INT_LITERAL' == TYPEOF(arg)): + return TRUE + if ('AUTOMOTIVE_DESIGN.REAL_LITERAL' == TYPEOF(arg)): + return FALSE + if ('AUTOMOTIVE_DESIGN.INT_NUMERIC_VARIABLE' == TYPEOF(arg)): + return TRUE + if ('AUTOMOTIVE_DESIGN.REAL_NUMERIC_VARIABLE' == TYPEOF(arg)): + return FALSE + if ('AUTOMOTIVE_DESIGN.ABS_FUNCTION' == TYPEOF(arg)): + return is_int_expr(arg.unary_numeric_expression.operand) + if ('AUTOMOTIVE_DESIGN.MINUS_FUNCTION' == TYPEOF(arg)): + return is_int_expr(arg.unary_numeric_expression.operand) + if ((((((((((('AUTOMOTIVE_DESIGN.SIN_FUNCTION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.COS_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.TAN_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.ASIN_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.ACOS_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.ATAN_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.EXP_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.LOG_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.LOG2_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.LOG10_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.SQUARE_ROOT_FUNCTION' == TYPEOF(arg))): + return FALSE + if (((('AUTOMOTIVE_DESIGN.PLUS_EXPRESSION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.MULT_EXPRESSION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.MAXIMUM_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.MINIMUM_FUNCTION' == TYPEOF(arg))): + for i in range(1,SIZEOF(arg.multiple_arity_numeric_expression.operands),1): + if ( not is_int_expr(arg.multiple_arity_numeric_expression.operands[i])): + return FALSE + return TRUE + if (('AUTOMOTIVE_DESIGN.MINUS_EXPRESSION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.POWER_EXPRESSION' == TYPEOF(arg))): + return is_int_expr(arg.binary_numeric_expression.operands[1]) and is_int_expr(arg.binary_numeric_expression.operands[2]) + if (('AUTOMOTIVE_DESIGN.DIV_EXPRESSION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.MOD_EXPRESSION' == TYPEOF(arg))): + return TRUE + if ('AUTOMOTIVE_DESIGN.SLASH_EXPRESSION' == TYPEOF(arg)): + return FALSE + if ('AUTOMOTIVE_DESIGN.LENGTH_FUNCTION' == TYPEOF(arg)): + return TRUE + if ('AUTOMOTIVE_DESIGN.VALUE_FUNCTION' == TYPEOF(arg)): + if ('AUTOMOTIVE_DESIGN.INT_VALUE_FUNCTION' == TYPEOF(arg)): + return TRUE + else: + return FALSE + if ('AUTOMOTIVE_DESIGN.INTEGER_DEFINED_FUNCTION' == TYPEOF(arg)): + return TRUE + if ('AUTOMOTIVE_DESIGN.REAL_DEFINED_FUNCTION' == TYPEOF(arg)): + return FALSE + if ('AUTOMOTIVE_DESIGN.BOOLEAN_DEFINED_FUNCTION' == TYPEOF(arg)): + return FALSE + if ('AUTOMOTIVE_DESIGN.STRING_DEFINED_FUNCTION' == TYPEOF(arg)): + return FALSE + return FALSE + +#################### + # FUNCTION dimension_of # +#################### +def dimension_of(item,): + ''' + :param item + :type item:geometric_representation_item + ''' + if ('AUTOMOTIVE_DESIGN.CARTESIAN_POINT' == TYPEOF(item)): + dim = SIZEOF(item.cartesian_point.coordinates) + return dim + if ('AUTOMOTIVE_DESIGN.DIRECTION' == TYPEOF(item)): + dim = SIZEOF(item.direction.direction_ratios) + return dim + if ('AUTOMOTIVE_DESIGN.VECTOR' == TYPEOF(item)): + dim = SIZEOF(item.vector.orientation.direction.direction_ratios) + return dim + x = using_representations(item) + y = x[1].context_of_items + dim = y.geometric_representation_context.coordinate_space_dimension + return dim + +#################### + # FUNCTION scalar_times_vector # +#################### +def scalar_times_vector(scalar,vec,): + ''' + :param scalar + :type scalar:REAL + :param vec + :type vec:vector_or_direction + ''' + if (( not EXISTS(scalar)) or ( not EXISTS(vec))): + return None + else: + if ('AUTOMOTIVE_DESIGN.VECTOR' == TYPEOF(vec)): + v = dummy_gri == direction(vec.vector.orientation.direction_ratios) + mag = scalar * vec.magnitude + else: + v = dummy_gri == direction(vec.direction_ratios) + mag = scalar + if (mag < 0): + for i in range(1,SIZEOF(v.direction_ratios),1): + v.direction_ratios[i] = -v.direction_ratios[i] + mag = -mag + result = dummy_gri == vector(normalise(v),mag) + return result + +#################### + # FUNCTION dimensions_for_si_unit # +#################### +def dimensions_for_si_unit(n,): + ''' + :param n + :type n:si_unit_name + ''' + case_selector = n + if case_selector == metre: + return dimensional_exponents(1,0,0,0,0,0,0) + elif case_selector == gram: + return dimensional_exponents(0,1,0,0,0,0,0) + elif case_selector == second: + return dimensional_exponents(0,0,1,0,0,0,0) + elif case_selector == ampere: + return dimensional_exponents(0,0,0,1,0,0,0) + elif case_selector == kelvin: + return dimensional_exponents(0,0,0,0,1,0,0) + elif case_selector == mole: + return dimensional_exponents(0,0,0,0,0,1,0) + elif case_selector == candela: + return dimensional_exponents(0,0,0,0,0,0,1) + elif case_selector == radian: + return dimensional_exponents(0,0,0,0,0,0,0) + elif case_selector == steradian: + return dimensional_exponents(0,0,0,0,0,0,0) + elif case_selector == hertz: + return dimensional_exponents(0,0,-1,0,0,0,0) + elif case_selector == newton: + return dimensional_exponents(1,1,-2,0,0,0,0) + elif case_selector == pascal: + return dimensional_exponents(-1,1,-2,0,0,0,0) + elif case_selector == joule: + return dimensional_exponents(2,1,-2,0,0,0,0) + elif case_selector == watt: + return dimensional_exponents(2,1,-3,0,0,0,0) + elif case_selector == coulomb: + return dimensional_exponents(0,0,1,1,0,0,0) + elif case_selector == volt: + return dimensional_exponents(2,1,-3,-1,0,0,0) + elif case_selector == farad: + return dimensional_exponents(-2,-1,4,1,0,0,0) + elif case_selector == ohm: + return dimensional_exponents(2,1,-3,-2,0,0,0) + elif case_selector == siemens: + return dimensional_exponents(-2,-1,3,2,0,0,0) + elif case_selector == weber: + return dimensional_exponents(2,1,-2,-1,0,0,0) + elif case_selector == tesla: + return dimensional_exponents(0,1,-2,-1,0,0,0) + elif case_selector == henry: + return dimensional_exponents(2,1,-2,-2,0,0,0) + elif case_selector == degree_celsius: + return dimensional_exponents(0,0,0,0,1,0,0) + elif case_selector == lumen: + return dimensional_exponents(0,0,0,0,0,0,1) + elif case_selector == lux: + return dimensional_exponents(-2,0,0,0,0,0,1) + elif case_selector == becquerel: + return dimensional_exponents(0,0,-1,0,0,0,0) + elif case_selector == gray: + return dimensional_exponents(2,0,-2,0,0,0,0) + elif case_selector == sievert: + return dimensional_exponents(2,0,-2,0,0,0,0) + else: + return None + +#################### + # FUNCTION assembly_shape_is_defined # +#################### +def assembly_shape_is_defined(assy,): + ''' + :param assy + :type assy:next_assembly_usage_occurrence + ''' + pd_set = bag_to_set(USEDIN(assy.related_product_definition,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION.DEFINITION')) + pdr_set = None + if (SIZEOF(pd_set) > 0): + for i in range(1,HIINDEX(pd_set),1): + sdr_set = sdr_set + None + if (SIZEOF(pdr_set) > 0): + for i in range(1,HIINDEX(pdr_set),1): + prop_set = prop_set + bag_to_set(USEDIN(pdr_set[i],'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION.DEFINITION')) + if (SIZEOF(prop_set) > 0): + for i in range(1,HIINDEX(prop_set),1): + sdr_set = sdr_set + None + if (SIZEOF(sdr_set) > 0): + for i in range(1,HIINDEX(sdr_set),1): + srr_set = None + pd_set = bag_to_set(USEDIN(assy.relating_product_definition,'AUTOMOTIVE_DESIGN.PROPERTY_DEFINITION.DEFINITION')) + if (SIZEOF(pd_set) > 0): + for i in range(1,HIINDEX(pd_set),1): + sdr1_set = sdr1_set + None + if ((SIZEOF(sdr_set) > 0) and (SIZEOF(sdr1_set) > 0)): + if (SIZEOF(srr_set) > 0): + for j in range(1,HIINDEX(srr_set),1): + if (SIZEOF(None * sdr1_set) >= 1): + pds_set = None + if (SIZEOF(pds_set) == 0): + return FALSE + for k in range(1,HIINDEX(pds_set),1): + if (SIZEOF(None) > 0): + return FALSE + return TRUE + +#################### + # FUNCTION surface_condition_correlation # +#################### +def surface_condition_correlation(pd,rep,): + ''' + :param pd + :type pd:property_definition + :param rep + :type rep:representation + ''' + case_selector = pd.name + if case_selector == 'visual appearance': + return pd.name == rep.name + elif case_selector == 'tactile appearance': + return pd.name == rep.name + elif case_selector == 'contact ratio': + return pd.name == rep.name + elif case_selector == 'hardness': + return pd.name == rep.name + elif case_selector == 'treatment result': + return pd.name == rep.name + elif case_selector == 'surface texture': + return pd.name == rep.name + else: + return UNKNOWN + +#################### + # FUNCTION open_shell_reversed # +#################### +def open_shell_reversed(a_shell,): + ''' + :param a_shell + :type a_shell:open_shell + ''' + if ('AUTOMOTIVE_DESIGN.ORIENTED_OPEN_SHELL' == TYPEOF(a_shell)): + the_reverse = ((dummy_tri == connected_face_set(a_shell.connected_face_set.cfs_faces)) == open_shell()) == oriented_open_shell(a_shell.oriented_open_shell.open_shell_element, not a_shell.oriented_open_shell.orientation) + else: + the_reverse = ((dummy_tri == connected_face_set(a_shell.connected_face_set.cfs_faces)) == open_shell()) == oriented_open_shell(a_shell,FALSE) + return the_reverse + +#################### + # FUNCTION acyclic_surface_replica # +#################### +def acyclic_surface_replica(rep,parent,): + ''' + :param rep + :type rep:surface_replica + :param parent + :type parent:surface + ''' + if ( not ('AUTOMOTIVE_DESIGN.SURFACE_REPLICA' == TYPEOF(parent))): + return TRUE + if (parent == rep): + return FALSE + else: + return acyclic_surface_replica(rep,parent.surface_replica.parent_surface) + +#################### + # FUNCTION gbsf_check_surface # +#################### +def gbsf_check_surface(sf,): + ''' + :param sf + :type sf:surface + ''' + if ((('AUTOMOTIVE_DESIGN.B_SPLINE_SURFACE' == TYPEOF(sf)) and (sf.b_spline_surface.self_intersect == FALSE)) or (sf.b_spline_surface.self_intersect == UNKNOWN)): + return TRUE + else: + if (SIZEOF(['AUTOMOTIVE_DESIGN.SPHERICAL_SURFACE','AUTOMOTIVE_DESIGN.TOROIDAL_SURFACE','AUTOMOTIVE_DESIGN.CURVE_BOUNDED_SURFACE','AUTOMOTIVE_DESIGN.RECTANGULAR_TRIMMED_SURFACE'] * TYPEOF(sf)) == 1): + return TRUE + else: + if ((('AUTOMOTIVE_DESIGN.OFFSET_SURFACE' == TYPEOF(sf)) and (sf.offset_surface.self_intersect == FALSE)) or (sf.offset_surface.self_intersect == UNKNOWN)): + return gbsf_check_surface(sf.offset_surface.basis_surface) + else: + if ('AUTOMOTIVE_DESIGN.RECTANGULAR_COMPOSITE_SURFACE' == TYPEOF(sf)): + for i in range(1,SIZEOF(sf.rectangular_composite_surface.segments),1): + for j in range(1,SIZEOF(sf.rectangular_composite_surface.segments[i]),1): + if ( not gbsf_check_surface(sf.rectangular_composite_surface.segments[i][j].parent_surface)): + return FALSE + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.SURFACE_REPLICA' == TYPEOF(sf)): + return gbsf_check_surface(sf.surface_replica.parent_surface) + else: + if ('AUTOMOTIVE_DESIGN.SURFACE_OF_REVOLUTION' == TYPEOF(sf)): + return gbsf_check_curve(sf.swept_surface.swept_curve) + return FALSE + +#################### + # FUNCTION msf_surface_check # +#################### +def msf_surface_check(surf,): + ''' + :param surf + :type surf:surface + ''' + if ('AUTOMOTIVE_DESIGN.ELEMENTARY_SURFACE' == TYPEOF(surf)): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.SWEPT_SURFACE' == TYPEOF(surf)): + return msf_curve_check(surf.swept_surface.swept_curve) + else: + if ((('AUTOMOTIVE_DESIGN.OFFSET_SURFACE' == TYPEOF(surf)) and (surf.offset_surface.self_intersect == FALSE)) or (surf.offset_surface.self_intersect == UNKNOWN)): + return msf_surface_check(surf.offset_surface.basis_surface) + else: + if ('AUTOMOTIVE_DESIGN.SURFACE_REPLICA' == TYPEOF(surf)): + return msf_surface_check(surf.surface_replica.parent_surface) + else: + if ((('AUTOMOTIVE_DESIGN.B_SPLINE_SURFACE' == TYPEOF(surf)) and (surf.b_spline_surface.self_intersect == FALSE)) or (surf.b_spline_surface.self_intersect == UNKNOWN)): + return TRUE + return FALSE + +#################### + # FUNCTION normalise # +#################### +def normalise(arg,): + ''' + :param arg + :type arg:vector_or_direction + ''' + if ( not EXISTS(arg)): + result = None + else: + ndim = arg.dim + if ('AUTOMOTIVE_DESIGN.VECTOR' == TYPEOF(arg)): + v = dummy_gri == direction(arg.vector.orientation.direction_ratios) + if (arg.magnitude == 0): + return None + else: + vec = dummy_gri == vector(v,1) + else: + v = dummy_gri == direction(arg.direction_ratios) + mag = 0 + for i in range(1,ndim,1): + mag = mag + (v.direction_ratios[i] * v.direction_ratios[i]) + if (mag > 0): + mag = SQRT(mag) + for i in range(1,ndim,1): + v.direction_ratios[i] = v.direction_ratios[i] / mag + if ('AUTOMOTIVE_DESIGN.VECTOR' == TYPEOF(arg)): + vec.orientation = v + result = vec + else: + result = v + else: + return None + return result + +#################### + # FUNCTION msb_shells # +#################### +def msb_shells(brep,): + ''' + :param brep + :type brep:manifold_solid_brep + ''' + if (SIZEOF(None) >= 1): + return_set = return_set + brep.brep_with_voids.voids + return return_set + +#################### + # FUNCTION nmsf_surface_check # +#################### +def nmsf_surface_check(surf,): + ''' + :param surf + :type surf:surface + ''' + if ('AUTOMOTIVE_DESIGN.ELEMENTARY_SURFACE' == TYPEOF(surf)): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.SWEPT_SURFACE' == TYPEOF(surf)): + return nmsf_curve_check(surf.swept_surface.swept_curve) + else: + if ((('AUTOMOTIVE_DESIGN.OFFSET_SURFACE' == TYPEOF(surf)) and (surf.offset_surface.self_intersect == FALSE)) or (surf.offset_surface.self_intersect == UNKNOWN)): + return nmsf_surface_check(surf.offset_surface.basis_surface) + else: + if ('AUTOMOTIVE_DESIGN.SURFACE_REPLICA' == TYPEOF(surf)): + return nmsf_surface_check(surf.surface_replica.parent_surface) + else: + if ((('AUTOMOTIVE_DESIGN.B_SPLINE_SURFACE' == TYPEOF(surf)) and (surf.b_spline_surface.self_intersect == FALSE)) or (surf.b_spline_surface.self_intersect == UNKNOWN)): + return TRUE + return FALSE + +#################### + # FUNCTION mixed_loop_type_set # +#################### +def mixed_loop_type_set(l,): + ''' + :param l + :type l:(null) + ''' + if (SIZEOF(l) <= 1): + return FALSE + poly_loop_type = 'AUTOMOTIVE_DESIGN.POLY_LOOP' == TYPEOF(l[1]) + for i in range(2,SIZEOF(l),1): + if (('AUTOMOTIVE_DESIGN.POLY_LOOP' == TYPEOF(l[i])) != poly_loop_type): + return TRUE + return FALSE + +#################### + # FUNCTION derive_dimensional_exponents # +#################### +def derive_dimensional_exponents(x,): + ''' + :param x + :type x:unit + ''' + if ('AUTOMOTIVE_DESIGN.DERIVED_UNIT' == TYPEOF(x)): + for i in range(LOINDEX(x.derived_unit.elements),HIINDEX(x.derived_unit.elements),1): + result.length_exponent = result.length_exponent + (x.derived_unit.elements[i].derived_unit_element.exponent * x.derived_unit.elements[i].derived_unit_element.unit.named_unit.dimensions.length_exponent) + result.mass_exponent = result.mass_exponent + (x.derived_unit.elements[i].derived_unit_element.exponent * x.derived_unit.elements[i].derived_unit_element.unit.named_unit.dimensions.mass_exponent) + result.time_exponent = result.time_exponent + (x.derived_unit.elements[i].derived_unit_element.exponent * x.derived_unit.elements[i].derived_unit_element.unit.named_unit.dimensions.time_exponent) + result.electric_current_exponent = result.electric_current_exponent + (x.derived_unit.elements[i].derived_unit_element.exponent * x.derived_unit.elements[i].derived_unit_element.unit.named_unit.dimensions.electric_current_exponent) + result.thermodynamic_temperature_exponent = result.thermodynamic_temperature_exponent + (x.derived_unit.elements[i].derived_unit_element.exponent * x.derived_unit.elements[i].derived_unit_element.unit.named_unit.dimensions.thermodynamic_temperature_exponent) + result.amount_of_substance_exponent = result.amount_of_substance_exponent + (x.derived_unit.elements[i].derived_unit_element.exponent * x.derived_unit.elements[i].derived_unit_element.unit.named_unit.dimensions.amount_of_substance_exponent) + result.luminous_intensity_exponent = result.luminous_intensity_exponent + (x.derived_unit.elements[i].derived_unit_element.exponent * x.derived_unit.elements[i].derived_unit_element.unit.named_unit.dimensions.luminous_intensity_exponent) + else: + result = x.named_unit.dimensions + return result + +#################### + # FUNCTION curve_weights_positive # +#################### +def curve_weights_positive(b,): + ''' + :param b + :type b:rational_b_spline_curve + ''' + for i in range(0,b.upper_index_on_control_points,1): + if (b.weights[i] <= 0): + result = FALSE + return result + return result + +#################### + # FUNCTION type_check_function # +#################### +def type_check_function(the_type,sub_names,criterion,): + ''' + :param the_type + :type the_type:(null) + :param sub_names + :type sub_names:(null) + :param criterion + :type criterion:INTEGER + ''' + if ((( not EXISTS(the_type)) or ( not ((0 <= criterion) and (criterion <= 3)))) or (SIZEOF(sub_names) == 0)): + return UNKNOWN + else: + case_selector = criterion + if case_selector == 0: + return SIZEOF(sub_names * TYPEOF(the_type)) > 0 + elif case_selector == 1: + return SIZEOF(sub_names * TYPEOF(the_type)) == 0 + elif case_selector == 2: + return SIZEOF(sub_names * TYPEOF(the_type)) == 1 + elif case_selector == 3: + return SIZEOF(sub_names * TYPEOF(the_type)) <= 1 + +#################### + # FUNCTION valid_geometrically_bounded_wf_point # +#################### +def valid_geometrically_bounded_wf_point(pnt,): + ''' + :param pnt + :type pnt:point + ''' + if ('AUTOMOTIVE_DESIGN.CARTESIAN_POINT' == TYPEOF(pnt)): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.POINT_ON_CURVE' == TYPEOF(pnt)): + return valid_geometrically_bounded_wf_curve(pnt.point_on_curve.basis_curve) + else: + if ('AUTOMOTIVE_DESIGN.POINT_REPLICA' == TYPEOF(pnt)): + return valid_geometrically_bounded_wf_point(pnt.point_replica.parent_pt) + return FALSE + +#################### + # FUNCTION path_head_to_tail # +#################### +def path_head_to_tail(a_path,): + ''' + :param a_path + :type a_path:path + ''' + n = SIZEOF(a_path.edge_list) + for i in range(2,n,1): + p = p and (a_path.edge_list[i - 1].edge_end == a_path.edge_list[i].edge_start) + return p + +#################### + # FUNCTION path_reversed # +#################### +def path_reversed(a_path,): + ''' + :param a_path + :type a_path:path + ''' + if ('AUTOMOTIVE_DESIGN.ORIENTED_PATH' == TYPEOF(a_path)): + the_reverse = (dummy_tri == path(list_of_topology_reversed(a_path.edge_list))) == oriented_path(a_path.oriented_path.path_element, not a_path.oriented_path.orientation) + else: + the_reverse = (dummy_tri == path(list_of_topology_reversed(a_path.edge_list))) == oriented_path(a_path,FALSE) + return the_reverse + +#################### + # FUNCTION get_id_value # +#################### +def get_id_value(obj,): + ''' + :param obj + :type obj:id_attribute_select + ''' + if (SIZEOF(id_bag) == 1): + return id_bag[1].attribute_value + else: + return None + +#################### + # FUNCTION aspect_ratio # +#################### +def aspect_ratio(p,): + ''' + :param p + :type p:planar_box + ''' + if ((p.size_in_x > 0) and (p.size_in_y > 0)): + return p.size_in_x / p.size_in_y + else: + return None + +#################### + # FUNCTION convert_plane_angle_for_pair_from_radian # +#################### +def convert_plane_angle_for_pair_from_radian(pair,angle_expr,): + ''' + :param pair + :type pair:kinematic_pair + :param angle_expr + :type angle_expr:REAL + ''' + link_cntxt = link_rep.representation.context_of_items + if ( not ('AUTOMOTIVE_DESIGN.GLOBAL_UNIT_ASSIGNED_CONTEXT' == TYPEOF(link_cntxt))): + return None + pa_units = None + if (SIZEOF(pa_units) != 1): + return None + pau = pa_units[1] + if (( not ('AUTOMOTIVE_DESIGN.SI_UNIT' == TYPEOF(pau))) and ( not ('AUTOMOTIVE_DESIGN.CONVERSION_BASED_UNIT' == TYPEOF(pau)))): + return None + for while 'AUTOMOTIVE_DESIGN.CONVERSION_BASED_UNIT' == TYPEOF(pau) conv_factor = conv_factor * pau.conversion_based_unit.conversion_factor.value_component + pau = pau.conversion_based_unit.conversion_factor.unit_component + if ((( not ('AUTOMOTIVE_DESIGN.SI_UNIT' == TYPEOF(pau))) and ( not ('AUTOMOTIVE_DESIGN.CONVERSION_BASED_UNIT' == TYPEOF(pau)))) or ( not ('AUTOMOTIVE_DESIGN.PLANE_ANGLE_UNIT' == TYPEOF(pau)))): + return None + if (pau.si_unit.name != si_unit_name.radian): + return None + case_selector = pau.si_unit.prefix + if case_selector == si_prefix.exa: + conv_factor = 1e+018 * conv_factor + elif case_selector == si_prefix.peta: + conv_factor = 1e+015 * conv_factor + elif case_selector == si_prefix.tera: + conv_factor = 1e+012 * conv_factor + elif case_selector == si_prefix.giga: + conv_factor = 1e+009 * conv_factor + elif case_selector == si_prefix.mega: + conv_factor = 1e+006 * conv_factor + elif case_selector == si_prefix.kilo: + conv_factor = 1000 * conv_factor + elif case_selector == si_prefix.hecto: + conv_factor = 100 * conv_factor + elif case_selector == si_prefix.deca: + conv_factor = 10 * conv_factor + elif case_selector == si_prefix.deci: + conv_factor = 0.1 * conv_factor + elif case_selector == si_prefix.centi: + conv_factor = 0.01 * conv_factor + elif case_selector == si_prefix.milli: + conv_factor = 0.001 * conv_factor + elif case_selector == si_prefix.micro: + conv_factor = 1e-006 * conv_factor + elif case_selector == si_prefix.nano: + conv_factor = 1e-009 * conv_factor + elif case_selector == si_prefix.pico: + conv_factor = 1e-012 * conv_factor + elif case_selector == si_prefix.femto: + conv_factor = 1e-015 * conv_factor + elif case_selector == si_prefix.atto: + conv_factor = 1e-018 * conv_factor + result = angle_expr / conv_factor + return result + +#################### + # FUNCTION is_acyclic # +#################### +def is_acyclic(arg,): + ''' + :param arg + :type arg:generic_expression + ''' + return acyclic(arg,[]) + +#################### + # FUNCTION check_text_alignment # +#################### +def check_text_alignment(ct,): + ''' + :param ct + :type ct:composite_text + ''' + for i in range(1,HIINDEX(ct.collected_text),1): + a = a + [ct.collected_text[i].text_literal.alignment] + return SIZEOF(a) == 1 + +#################### + # FUNCTION leap_year # +#################### +def leap_year(year,): + ''' + :param year + :type year:INTEGER + ''' + if ((((year % 4) == 0) and ((year % 100) != 0)) or ((year % 400) == 0)): + return TRUE + else: + return FALSE + +#################### + # FUNCTION face_reversed # +#################### +def face_reversed(a_face,): + ''' + :param a_face + :type a_face:face + ''' + if ('AUTOMOTIVE_DESIGN.ORIENTED_FACE' == TYPEOF(a_face)): + the_reverse = (dummy_tri == face(set_of_topology_reversed(a_face.bounds))) == oriented_face(a_face.oriented_face.face_element, not a_face.oriented_face.orientation) + else: + the_reverse = (dummy_tri == face(set_of_topology_reversed(a_face.bounds))) == oriented_face(a_face,FALSE) + return the_reverse + +#################### + # FUNCTION get_description_value # +#################### +def get_description_value(obj,): + ''' + :param obj + :type obj:description_attribute_select + ''' + if (SIZEOF(description_bag) == 1): + return description_bag[1].attribute_value + else: + return None + +#################### + # FUNCTION constraints_param_b_spline # +#################### +def constraints_param_b_spline(degree,up_knots,up_cp,knot_mult,knots,): + ''' + :param degree + :type degree:INTEGER + :param up_knots + :type up_knots:INTEGER + :param up_cp + :type up_cp:INTEGER + :param knot_mult + :type knot_mult:(null) + :param knots + :type knots:(null) + ''' + sum = knot_mult[1] + for i in range(2,up_knots,1): + sum = sum + knot_mult[i] + if ((((degree < 1) or (up_knots < 2)) or (up_cp < degree)) or (sum != ((degree + up_cp) + 2))): + result = FALSE + return result + k = knot_mult[1] + if ((k < 1) or (k > (degree + 1))): + result = FALSE + return result + for i in range(2,up_knots,1): + if ((knot_mult[i] < 1) or (knots[i] <= knots[i - 1])): + result = FALSE + return result + k = knot_mult[i] + if ((i < up_knots) and (k > degree)): + result = FALSE + return result + if ((i == up_knots) and (k > (degree + 1))): + result = FALSE + return result + return result + +#################### + # FUNCTION value_range_aggregate_rep_item # +#################### +def value_range_aggregate_rep_item(agg,): + ''' + :param agg + :type agg:(null) + ''' + if ((SIZEOF(agg) == 3) and (SIZEOF(None) == 1)): + return TRUE + else: + return FALSE + +#################### + # FUNCTION frame_associated_to_background # +#################### +def frame_associated_to_background(frame,background,): + ''' + :param frame + :type frame:rigid_placement + :param background + :type background:kinematic_frame_background + ''' + rep_bag = None + if (SIZEOF(rep_bag) == 0): + return FALSE + trf_bag = USEDIN(frame,'AUTOMOTIVE_DESIGN.KINEMATIC_FRAME_BASED_TRANSFORMATION.TRANSFORMATOR') + if (SIZEOF(trf_bag) == 0): + return FALSE + for i in range(1,HIINDEX(rep_bag),1): + rep = rep_bag[i] + ass_bag = None + if (SIZEOF(ass_bag) > 0): + for j in range(1,HIINDEX(ass_bag),1): + ass = ass_bag[j] + trm_bag = None + if (SIZEOF(trm_bag) > 0): + return TRUE + return FALSE + +#################### + # FUNCTION representation_of_link # +#################### +def representation_of_link(link,): + ''' + :param link + :type link:kinematic_link + ''' + link_rep_rel = USEDIN(link,'AUTOMOTIVE_DESIGN.KINEMATIC_LINK_REPRESENTATION_RELATION.TOPOLOGICAL_ASPECTS') + if (SIZEOF(link_rep_rel) == 0): + return None + else: + return link_rep_rel[1].geometric_aspects + +#################### + # FUNCTION ypr_index # +#################### +def ypr_index(ypr,): + ''' + :param ypr + :type ypr:ypr_enumeration + ''' + case_selector = ypr + if case_selector == yaw: + return 1 + elif case_selector == pitch: + return 2 + elif case_selector == roll: + return 3 + return None + +#################### + # FUNCTION acyclic_mapped_item_usage # +#################### +def acyclic_mapped_item_usage(rep,): + ''' + :param rep + :type rep:representation + ''' + items = None + if (SIZEOF(items) == 0): + return FALSE + else: + for i in range(1,HIINDEX(items),1): + if (items[i].mapped_item.mapping_source.mapped_representation == rep): + return TRUE + else: + return acyclic_mapped_item_usage(items[i].mapped_item.mapping_source.mapped_representation) + return FALSE + +#################### + # FUNCTION plane_angle_for_pair_in_radian # +#################### +def plane_angle_for_pair_in_radian(pair,angle,): + ''' + :param pair + :type pair:kinematic_pair + :param angle + :type angle:REAL + ''' + link_cntxt = link_rep.representation.context_of_items + if ( not ('AUTOMOTIVE_DESIGN.GLOBAL_UNIT_ASSIGNED_CONTEXT' == TYPEOF(link_cntxt))): + return None + pa_units = None + if (SIZEOF(pa_units) != 1): + return None + pau = pa_units[1] + if (( not ('AUTOMOTIVE_DESIGN.SI_UNIT' == TYPEOF(pau))) and ( not ('AUTOMOTIVE_DESIGN.CONVERSION_BASED_UNIT' == TYPEOF(pau)))): + return None + for while 'AUTOMOTIVE_DESIGN.CONVERSION_BASED_UNIT' == TYPEOF(pau) converted_angle = converted_angle * pau.conversion_based_unit.conversion_factor.value_component + pau = pau.conversion_based_unit.conversion_factor.unit_component + if ((( not ('AUTOMOTIVE_DESIGN.SI_UNIT' == TYPEOF(pau))) and ( not ('AUTOMOTIVE_DESIGN.CONVERSION_BASED_UNIT' == TYPEOF(pau)))) or ( not ('AUTOMOTIVE_DESIGN.PLANE_ANGLE_UNIT' == TYPEOF(pau)))): + return None + if (pau.si_unit.name != si_unit_name.radian): + return None + case_selector = pau.si_unit.prefix + if case_selector == si_prefix.exa: + return 1e+018 * converted_angle + elif case_selector == si_prefix.peta: + return 1e+015 * converted_angle + elif case_selector == si_prefix.tera: + return 1e+012 * converted_angle + elif case_selector == si_prefix.giga: + return 1e+009 * converted_angle + elif case_selector == si_prefix.mega: + return 1e+006 * converted_angle + elif case_selector == si_prefix.kilo: + return 1000 * converted_angle + elif case_selector == si_prefix.hecto: + return 100 * converted_angle + elif case_selector == si_prefix.deca: + return 10 * converted_angle + elif case_selector == si_prefix.deci: + return 0.1 * converted_angle + elif case_selector == si_prefix.centi: + return 0.01 * converted_angle + elif case_selector == si_prefix.milli: + return 0.001 * converted_angle + elif case_selector == si_prefix.micro: + return 1e-006 * converted_angle + elif case_selector == si_prefix.nano: + return 1e-009 * converted_angle + elif case_selector == si_prefix.pico: + return 1e-012 * converted_angle + elif case_selector == si_prefix.femto: + return 1e-015 * converted_angle + elif case_selector == si_prefix.atto: + return 1e-018 * converted_angle + else: + return converted_angle + +#################### + # FUNCTION get_multi_language # +#################### +def get_multi_language(x,): + ''' + :param x + :type x:multi_language_attribute_assignment + ''' + if (SIZEOF(alas) > 0): + return alas[1].language + return None + +#################### + # FUNCTION unique_link_usage # +#################### +def unique_link_usage(link,): + ''' + :param link + :type link:kinematic_link + ''' + joints = bag_to_set(USEDIN(link,'AUTOMOTIVE_DESIGN.KINEMATIC_JOINT.FIRST_LINK') + USEDIN(link,'AUTOMOTIVE_DESIGN.KINEMATIC_JOINT.SECOND_LINK')) + struct = joints[1].structure + for i in range(2,SIZEOF(joints),1): + if (joints[i].structure != struct): + return FALSE + mechs = bag_to_set(USEDIN(struct,'AUTOMOTIVE_DESIGN.MECHANISM.STRUCTURE_DEFINITION')) + if (SIZEOF(mechs) != 1): + return FALSE + return TRUE + +#################### + # FUNCTION using_representations # +#################### +def using_representations(item,): + ''' + :param item + :type item:founded_item_select + ''' + results = [] + result_bag = USEDIN(item,'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') + if (SIZEOF(result_bag) > 0): + for i in range(1,HIINDEX(result_bag),1): + results = results + result_bag[i] + intermediate_items = using_items(item,[]) + if (SIZEOF(intermediate_items) > 0): + for i in range(1,HIINDEX(intermediate_items),1): + result_bag = USEDIN(intermediate_items[i],'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') + if (SIZEOF(result_bag) > 0): + for j in range(1,HIINDEX(result_bag),1): + results = results + result_bag[j] + return results + +#################### + # FUNCTION control_characters_free # +#################### +def control_characters_free(s,): + ''' + :param s + :type s:STRING + ''' + for i in range(1,LENGTH(s),1): + ch = s[i] + if (((ch == '\x9') or (ch == '\xA')) or (ch == '\xD')): + return FALSE + return TRUE + +#################### + # FUNCTION associated_surface # +#################### +def associated_surface(arg,): + ''' + :param arg + :type arg:pcurve_or_surface + ''' + if ('AUTOMOTIVE_DESIGN.PCURVE' == TYPEOF(arg)): + surf = arg.pcurve.basis_surface + else: + surf = arg + return surf + +#################### + # FUNCTION acyclic_point_replica # +#################### +def acyclic_point_replica(rep,parent,): + ''' + :param rep + :type rep:point_replica + :param parent + :type parent:point + ''' + if ( not ('AUTOMOTIVE_DESIGN.POINT_REPLICA' == TYPEOF(parent))): + return TRUE + if (parent == rep): + return FALSE + else: + return acyclic_point_replica(rep,parent.point_replica.parent_pt) + +#################### + # FUNCTION cross_product # +#################### +def cross_product(arg1,arg2,): + ''' + :param arg1 + :type arg1:direction + :param arg2 + :type arg2:direction + ''' + if (((( not EXISTS(arg1)) or (arg1.dim == 2)) or ( not EXISTS(arg2))) or (arg2.dim == 2)): + return None + else: + v1 = normalise(arg1).direction_ratios + v2 = normalise(arg2).direction_ratios + res = dummy_gri == direction([(v1[2] * v2[3]) - (v1[3] * v2[2]),(v1[3] * v2[1]) - (v1[1] * v2[3]),(v1[1] * v2[2]) - (v1[2] * v2[1])]) + mag = 0 + for i in range(1,3,1): + mag = mag + (res.direction_ratios[i] * res.direction_ratios[i]) + if (mag > 0): + result = dummy_gri == vector(res,SQRT(mag)) + else: + result = dummy_gri == vector(arg1,0) + return result + +#################### + # FUNCTION valid_units # +#################### +def valid_units(m,): + ''' + :param m + :type m:measure_with_unit + ''' + if ('AUTOMOTIVE_DESIGN.LENGTH_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(1,0,0,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.MASS_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,1,0,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.TIME_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,1,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.ELECTRIC_CURRENT_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,1,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.THERMODYNAMIC_TEMPERATURE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,0,1,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.CELSIUS_TEMPERATURE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,0,1,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.AMOUNT_OF_SUBSTANCE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,0,0,1,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.LUMINOUS_INTENSITY_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,0,0,0,1)): + return FALSE + if ('AUTOMOTIVE_DESIGN.PLANE_ANGLE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.SOLID_ANGLE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.AREA_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(2,0,0,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.VOLUME_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(3,0,0,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.RATIO_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.POSITIVE_LENGTH_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(1,0,0,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.POSITIVE_PLANE_ANGLE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.ACCELERATION_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(1,0,-2,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.CAPACITANCE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(-2,-1,4,1,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.ELECTRIC_CHARGE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,1,1,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.CONDUCTANCE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(-2,-1,3,2,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.ELECTRIC_POTENTIAL_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(2,1,-3,-1,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.ENERGY_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(2,1,-2,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.FORCE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(1,1,-2,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.FREQUENCY_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,-1,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.ILLUMINANCE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(-2,0,0,0,0,0,1)): + return FALSE + if ('AUTOMOTIVE_DESIGN.INDUCTANCE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(2,1,-2,-2,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.LUMINOUS_FLUX_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,0,0,0,0,1)): + return FALSE + if ('AUTOMOTIVE_DESIGN.MAGNETIC_FLUX_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(2,1,-2,-1,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.MAGNETIC_FLUX_DENSITY_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,1,-2,-1,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.POWER_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(2,1,-3,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.PRESSURE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(-1,1,-2,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.RESISTANCE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(2,1,-3,-2,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.VELOCITY_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(1,0,-1,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.RADIOACTIVITY_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(0,0,-1,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.ABSORBED_DOSE_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(2,0,-2,0,0,0,0)): + return FALSE + if ('AUTOMOTIVE_DESIGN.DOSE_EQUIVALENT_MEASURE' == TYPEOF(m.value_component)): + if (derive_dimensional_exponents(m.unit_component) != dimensional_exponents(2,0,-2,0,0,0,0)): + return FALSE + return TRUE + +#################### + # FUNCTION representations_mapped_into # +#################### +def representations_mapped_into(rep,): + ''' + :param rep + :type rep:representation + ''' + rm = bag_to_set(USEDIN(rep,'AUTOMOTIVE_DESIGN.REPRESENTATION_MAP.MAPPED_REPRESENTATION')) + for i in range(1,HIINDEX(rm),1): + mi = mi + rm[i].map_usage + for j in range(1,HIINDEX(mi),1): + results = results + USEDIN(mi[j],'AUTOMOTIVE_DESIGN.REPRESENTATION.ITEMS') + return results + +#################### + # FUNCTION constraints_rectangular_composite_surface # +#################### +def constraints_rectangular_composite_surface(s,): + ''' + :param s + :type s:rectangular_composite_surface + ''' + for i in range(1,s.n_u,1): + for j in range(1,s.n_v,1): + if ( not (('AUTOMOTIVE_DESIGN.B_SPLINE_SURFACE' == TYPEOF(s.segments[i][j].parent_surface)) or ('AUTOMOTIVE_DESIGN.RECTANGULAR_TRIMMED_SURFACE' == TYPEOF(s.segments[i][j].parent_surface)))): + return FALSE + for i in range(1,s.n_u - 1,1): + for j in range(1,s.n_v,1): + if (s.segments[i][j].u_transition == discontinuous): + return FALSE + for i in range(1,s.n_u,1): + for j in range(1,s.n_v - 1,1): + if (s.segments[i][j].v_transition == discontinuous): + return FALSE + return TRUE + +#################### + # FUNCTION suitably_based_mechanism # +#################### +def suitably_based_mechanism(mbp,mech,): + ''' + :param mbp + :type mbp:mechanism_base_placement + :param mech + :type mech:mechanism + ''' + kprop = mech.containing_property + if ('AUTOMOTIVE_DESIGN.KINEMATIC_GROUND_REPRESENTATION' == TYPEOF(mbp.representation_relationship.rep_1)): + kgrep = mbp.representation_relationship.rep_1 + if (kgrep.property.property_definition_representation.definition == kprop): + return TRUE + else: + return FALSE + else: + klrep = mbp.representation_relationship.rep_1 + klnk = klrep.link_representation_relation.topological_aspects + kjnts = USEDIN(klnk,'AUTOMOTIVE_DESIGN.KINEMATIC_JOINT.FIRST_LINK') + USEDIN(klnk,'AUTOMOTIVE_DESIGN.KINEMATIC_JOINT.SECOND_LINK') + nmechs = USEDIN(kjnts[1].structure,'AUTOMOTIVE_DESIGN.MECHANISM.STRUCTURE_DEFINITION') + if (nmechs[1] == mech): + return FALSE + else: + if (nmechs[1].containing_property != kprop): + return FALSE + else: + nmbps = USEDIN(nmechs[1],'AUTOMOTIVE_DESIGN.MECHANISM_BASE_PLACEMENT.BASE_OF_MECHANISM') + if (SIZEOF(nmbps) == 0): + return FALSE + else: + return suitably_based_mechanism(nmbps[1],mech) + +#################### + # FUNCTION closed_shell_reversed # +#################### +def closed_shell_reversed(a_shell,): + ''' + :param a_shell + :type a_shell:closed_shell + ''' + if ('AUTOMOTIVE_DESIGN.ORIENTED_CLOSED_SHELL' == TYPEOF(a_shell)): + the_reverse = ((dummy_tri == connected_face_set(a_shell.connected_face_set.cfs_faces)) == closed_shell()) == oriented_closed_shell(a_shell.oriented_closed_shell.closed_shell_element, not a_shell.oriented_closed_shell.orientation) + else: + the_reverse = ((dummy_tri == connected_face_set(a_shell.connected_face_set.cfs_faces)) == closed_shell()) == oriented_closed_shell(a_shell,FALSE) + return the_reverse + +#################### + # FUNCTION boolean_choose # +#################### +def boolean_choose(b,choice1,choice2,): + ''' + :param b + :type b:BOOLEAN + :param choice1 + :type choice1:(null) + :param choice2 + :type choice2:(null) + ''' + if (b): + return choice1 + else: + return choice2 + +#################### + # FUNCTION valid_time # +#################### +def valid_time(time,): + ''' + :param time + :type time:local_time + ''' + if (EXISTS(time.second_component)): + return EXISTS(time.minute_component) + else: + return TRUE + +#################### + # FUNCTION is_sql_mappable # +#################### +def is_sql_mappable(arg,): + ''' + :param arg + :type arg:expression + ''' + if ('AUTOMOTIVE_DESIGN.SIMPLE_NUMERIC_EXPRESSION' == TYPEOF(arg)): + return TRUE + if ('AUTOMOTIVE_DESIGN.SQL_MAPPABLE_DEFINED_FUNCTION' == TYPEOF(arg)): + return TRUE + if ('AUTOMOTIVE_DESIGN.MINUS_FUNCTION' == TYPEOF(arg)): + return is_sql_mappable(arg.unary_numeric_expression.operand) + if (((((((((((((('AUTOMOTIVE_DESIGN.ABS_FUNCTION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.SIN_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.COS_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.TAN_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.ASIN_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.ACOS_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.ATAN_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.EXP_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.LOG_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.LOG2_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.LOG10_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.SQUARE_ROOT_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.VALUE_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.LENGTH_FUNCTION' == TYPEOF(arg))): + return FALSE + if (((('AUTOMOTIVE_DESIGN.PLUS_EXPRESSION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.MULT_EXPRESSION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.MAXIMUM_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.MINIMUM_FUNCTION' == TYPEOF(arg))): + for i in range(1,SIZEOF(arg.multiple_arity_numeric_expression.operands),1): + if ( not is_sql_mappable(arg.multiple_arity_numeric_expression.operands[i])): + return FALSE + return TRUE + if (('AUTOMOTIVE_DESIGN.MINUS_EXPRESSION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.SLASH_EXPRESSION' == TYPEOF(arg))): + return is_sql_mappable(arg.binary_numeric_expression.operands[1]) and is_sql_mappable(arg.binary_numeric_expression.operands[2]) + if ((('AUTOMOTIVE_DESIGN.DIV_EXPRESSION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.MOD_EXPRESSION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.POWER_EXPRESSION' == TYPEOF(arg))): + return FALSE + if ('AUTOMOTIVE_DESIGN.SIMPLE_BOOLEAN_EXPRESSION' == TYPEOF(arg)): + return TRUE + if ('AUTOMOTIVE_DESIGN.NOT_EXPRESSION' == TYPEOF(arg)): + return is_sql_mappable(arg.unary_generic_expression.operand) + if (('AUTOMOTIVE_DESIGN.ODD_FUNCTION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.XOR_EXPRESSION' == TYPEOF(arg))): + return FALSE + if (('AUTOMOTIVE_DESIGN.AND_EXPRESSION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.OR_EXPRESSION' == TYPEOF(arg))): + for i in range(1,SIZEOF(arg.multiple_arity_boolean_expression.operands),1): + if ( not is_sql_mappable(arg.multiple_arity_boolean_expression.operands[i])): + return FALSE + return TRUE + if ('AUTOMOTIVE_DESIGN.EQUALS_EXPRESSION' == TYPEOF(arg)): + return is_sql_mappable(arg.binary_generic_expression.operands[1]) and is_sql_mappable(arg.binary_generic_expression.operands[2]) + if ((((((('AUTOMOTIVE_DESIGN.COMPARISON_EQUAL' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.COMPARISON_GREATER' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.COMPARISON_GREATER_EQUAL' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.COMPARISON_LESS' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.COMPARISON_LESS_EQUAL' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.COMPARISON_NOT_EQUAL' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.LIKE_EXPRESSION' == TYPEOF(arg))): + return is_sql_mappable(arg.comparison_expression.operands[1]) and is_sql_mappable(arg.comparison_expression.operands[2]) + if ('AUTOMOTIVE_DESIGN.INTERVAL_EXPRESSION' == TYPEOF(arg)): + return (is_sql_mappable(arg.interval_expression.interval_low) and is_sql_mappable(arg.interval_expression.interval_high)) and is_sql_mappable(arg.interval_expression.interval_item) + if ((('AUTOMOTIVE_DESIGN.NUMERIC_DEFINED_FUNCTION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.BOOLEAN_DEFINED_FUNCTION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.STRING_DEFINED_FUNCTION' == TYPEOF(arg))): + return FALSE + if ('AUTOMOTIVE_DESIGN.SIMPLE_STRING_EXPRESSION' == TYPEOF(arg)): + return TRUE + if (((('AUTOMOTIVE_DESIGN.INDEX_EXPRESSION' == TYPEOF(arg)) or ('AUTOMOTIVE_DESIGN.SUBSTRING_EXPRESSION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.CONCAT_EXPRESSION' == TYPEOF(arg))) or ('AUTOMOTIVE_DESIGN.FORMAT_FUNCTION' == TYPEOF(arg))): + return FALSE + return FALSE + +#################### + # FUNCTION valid_geometrically_bounded_wf_curve # +#################### +def valid_geometrically_bounded_wf_curve(crv,): + ''' + :param crv + :type crv:curve + ''' + if (SIZEOF(['AUTOMOTIVE_DESIGN.POLYLINE','AUTOMOTIVE_DESIGN.B_SPLINE_CURVE','AUTOMOTIVE_DESIGN.ELLIPSE','AUTOMOTIVE_DESIGN.CIRCLE'] * TYPEOF(crv)) == 1): + return TRUE + else: + if ('AUTOMOTIVE_DESIGN.TRIMMED_CURVE' == TYPEOF(crv)): + if (SIZEOF(['AUTOMOTIVE_DESIGN.LINE','AUTOMOTIVE_DESIGN.PARABOLA','AUTOMOTIVE_DESIGN.HYPERBOLA'] * TYPEOF(crv.trimmed_curve.basis_curve)) == 1): + return TRUE + else: + return valid_geometrically_bounded_wf_curve(crv.trimmed_curve.basis_curve) + else: + if ('AUTOMOTIVE_DESIGN.OFFSET_CURVE_3D' == TYPEOF(crv)): + return valid_geometrically_bounded_wf_curve(crv.offset_curve_3d.basis_curve) + else: + if ('AUTOMOTIVE_DESIGN.CURVE_REPLICA' == TYPEOF(crv)): + return valid_geometrically_bounded_wf_curve(crv.curve_replica.parent_curve) + else: + if ('AUTOMOTIVE_DESIGN.COMPOSITE_CURVE' == TYPEOF(crv)): + return SIZEOF(None) == 0 + return FALSE + +#################### + # FUNCTION dot_product # +#################### +def dot_product(arg1,arg2,): + ''' + :param arg1 + :type arg1:direction + :param arg2 + :type arg2:direction + ''' + if (( not EXISTS(arg1)) or ( not EXISTS(arg2))): + scalar = None + else: + if (arg1.dim != arg2.dim): + scalar = None + else: + vec1 = normalise(arg1) + vec2 = normalise(arg2) + ndim = arg1.dim + scalar = 0 + for i in range(1,ndim,1): + scalar = scalar + (vec1.direction_ratios[i] * vec2.direction_ratios[i]) + return scalar + +#################### + # FUNCTION get_role # +#################### +def get_role(obj,): + ''' + :param obj + :type obj:role_select + ''' + if (SIZEOF(role_bag) == 1): + return role_bag[1].role + else: + return None + +#################### + # FUNCTION acyclic_curve_replica # +#################### +def acyclic_curve_replica(rep,parent,): + ''' + :param rep + :type rep:curve_replica + :param parent + :type parent:curve + ''' + if ( not ('AUTOMOTIVE_DESIGN.CURVE_REPLICA' == TYPEOF(parent))): + return TRUE + if (parent == rep): + return FALSE + else: + return acyclic_curve_replica(rep,parent.curve_replica.parent_curve) + +#################### + # RULE restrict_multi_language_for_approval_relationship # +#################### +restrict_multi_language_for_approval_relationship = Rule() + +#################### + # RULE restrict_multi_language_for_action_relationship # +#################### +restrict_multi_language_for_action_relationship = Rule() + +#################### + # RULE subtype_exclusiveness_replicate_feature # +#################### +subtype_exclusiveness_replicate_feature = Rule() + +#################### + # RULE subtype_exclusiveness_shape_representation_feature_geometry # +#################### +subtype_exclusiveness_shape_representation_feature_geometry = Rule() + +#################### + # RULE restrict_configuration_design_for_product_class # +#################### +restrict_configuration_design_for_product_class = Rule() + +#################### + # RULE restrict_multi_language_for_action_method # +#################### +restrict_multi_language_for_action_method = Rule() + +#################### + # RULE versioned_action_request_requires_status # +#################### +versioned_action_request_requires_status = Rule() + +#################### + # RULE person_requires_person_and_organization # +#################### +person_requires_person_and_organization = Rule() + +#################### + # RULE restrict_multi_language_for_kinematic_pair # +#################### +restrict_multi_language_for_kinematic_pair = Rule() + +#################### + # RULE restrict_multi_language_for_product_related_product_category # +#################### +restrict_multi_language_for_product_related_product_category = Rule() + +#################### + # RULE dependent_instantiable_date_and_time # +#################### +dependent_instantiable_date_and_time = Rule() + +#################### + # RULE restrict_multi_language_for_organization_relationship # +#################### +restrict_multi_language_for_organization_relationship = Rule() + +#################### + # RULE dependent_instantiable_dimensional_size # +#################### +dependent_instantiable_dimensional_size = Rule() + +#################### + # RULE dependent_instantiable_person_and_organization_role # +#################### +dependent_instantiable_person_and_organization_role = Rule() + +#################### + # RULE drawing_sheet_annotation_layers # +#################### +drawing_sheet_annotation_layers = Rule() + +#################### + # RULE subtype_exclusiveness_pre_defined_symbol # +#################### +subtype_exclusiveness_pre_defined_symbol = Rule() + +#################### + # RULE subtype_mandatory_externally_defined_item # +#################### +subtype_mandatory_externally_defined_item = Rule() + +#################### + # RULE compatible_dimension # +#################### +compatible_dimension = Rule() + +#################### + # RULE dependent_instantiable_curve_style # +#################### +dependent_instantiable_curve_style = Rule() + +#################### + # RULE restrict_multi_language_for_geometric_tolerance # +#################### +restrict_multi_language_for_geometric_tolerance = Rule() + +#################### + # RULE restrict_multi_language_for_security_classification # +#################### +restrict_multi_language_for_security_classification = Rule() + +#################### + # RULE curve_font_usage # +#################### +curve_font_usage = Rule() + +#################### + # RULE restrict_camera_image_in_view # +#################### +restrict_camera_image_in_view = Rule() + +#################### + # RULE restrict_process_product_association # +#################### +restrict_process_product_association = Rule() + +#################### + # RULE subtype_mandatory_annotation_occurrence # +#################### +subtype_mandatory_annotation_occurrence = Rule() + +#################### + # RULE product_requires_id_owner # +#################### +product_requires_id_owner = Rule() + +#################### + # RULE restrict_multi_language_for_time_interval_role # +#################### +restrict_multi_language_for_time_interval_role = Rule() + +#################### + # RULE subtype_exclusiveness_feature_definition # +#################### +subtype_exclusiveness_feature_definition = Rule() + +#################### + # RULE product_requires_version # +#################### +product_requires_version = Rule() + +#################### + # RULE restrict_multi_language_for_identification_role # +#################### +restrict_multi_language_for_identification_role = Rule() + +#################### + # RULE restrict_alternative_definition # +#################### +restrict_alternative_definition = Rule() + +#################### + # RULE restrict_multi_language_for_representation # +#################### +restrict_multi_language_for_representation = Rule() + +#################### + # RULE dependent_instantiable_retention # +#################### +dependent_instantiable_retention = Rule() + +#################### + # RULE subtype_exclusiveness_geometric_tolerance # +#################### +subtype_exclusiveness_geometric_tolerance = Rule() + +#################### + # RULE restrict_multi_language_for_product_definition_formation # +#################### +restrict_multi_language_for_product_definition_formation = Rule() + +#################### + # RULE restrict_multi_language_for_property_definition # +#################### +restrict_multi_language_for_property_definition = Rule() + +#################### + # RULE restrict_multi_language_for_document_relationship # +#################### +restrict_multi_language_for_document_relationship = Rule() + +#################### + # RULE subtype_exclusiveness_mapped_item # +#################### +subtype_exclusiveness_mapped_item = Rule() + +#################### + # RULE subtype_exclusiveness_effectivity_context_assignment # +#################### +subtype_exclusiveness_effectivity_context_assignment = Rule() + +#################### + # RULE restrict_multi_language_for_action_property # +#################### +restrict_multi_language_for_action_property = Rule() + +#################### + # RULE versioned_action_request_requires_date_and_person_or_organization # +#################### +versioned_action_request_requires_date_and_person_or_organization = Rule() + +#################### + # RULE retention_requires_retention_assignment # +#################### +retention_requires_retention_assignment = Rule() + +#################### + # RULE subtype_mandatory_pre_defined_text_font # +#################### +subtype_mandatory_pre_defined_text_font = Rule() + +#################### + # RULE subtype_exclusiveness_group_assignment # +#################### +subtype_exclusiveness_group_assignment = Rule() + +#################### + # RULE restrict_zone_boundary # +#################### +restrict_zone_boundary = Rule() + +#################### + # RULE subtype_exclusiveness_presentation_area # +#################### +subtype_exclusiveness_presentation_area = Rule() + +#################### + # RULE restrict_multi_language_for_alternate_product_relationship # +#################### +restrict_multi_language_for_alternate_product_relationship = Rule() + +#################### + # RULE restrict_multi_language_for_effectivity # +#################### +restrict_multi_language_for_effectivity = Rule() + +#################### + # RULE subtype_exclusiveness_effectivity_assignment # +#################### +subtype_exclusiveness_effectivity_assignment = Rule() + +#################### + # RULE restrict_product_definition_for_mating_tree # +#################### +restrict_product_definition_for_mating_tree = Rule() + +#################### + # RULE restrict_version_assignment_for_action_directive # +#################### +restrict_version_assignment_for_action_directive = Rule() + +#################### + # RULE restrict_centre_of_mass_representation # +#################### +restrict_centre_of_mass_representation = Rule() + +#################### + # RULE restrict_version_assignment_for_document_file # +#################### +restrict_version_assignment_for_document_file = Rule() + +#################### + # RULE restrict_version_assignment_for_mechanical_design_geometric_presentation_representation # +#################### +restrict_version_assignment_for_mechanical_design_geometric_presentation_representation = Rule() + +#################### + # RULE restrict_multi_language_for_product_definition_substitute # +#################### +restrict_multi_language_for_product_definition_substitute = Rule() + +#################### + # RULE restrict_representation_for_document_content_property # +#################### +restrict_representation_for_document_content_property = Rule() + +#################### + # RULE restrict_multi_language_for_organizational_project # +#################### +restrict_multi_language_for_organizational_project = Rule() + +#################### + # RULE selected_instance_usage_requires_representation # +#################### +selected_instance_usage_requires_representation = Rule() + +#################### + # RULE subtype_exclusiveness_effectivity # +#################### +subtype_exclusiveness_effectivity = Rule() + +#################### + # RULE subtype_mandatory_founded_item # +#################### +subtype_mandatory_founded_item = Rule() + +#################### + # RULE dependent_instantiable_named_unit # +#################### +dependent_instantiable_named_unit = Rule() + +#################### + # RULE restrict_name_assignment_for_kinematic_link # +#################### +restrict_name_assignment_for_kinematic_link = Rule() + +#################### + # RULE restrict_multi_language_for_person_and_organization_role # +#################### +restrict_multi_language_for_person_and_organization_role = Rule() + +#################### + # RULE restrict_multi_language_for_product_definition_relationship # +#################### +restrict_multi_language_for_product_definition_relationship = Rule() + +#################### + # RULE application_protocol_definition_required # +#################### +application_protocol_definition_required = Rule() + +#################### + # RULE subtype_exclusiveness_action # +#################### +subtype_exclusiveness_action = Rule() + +#################### + # RULE subtype_mandatory_draughting_callout # +#################### +subtype_mandatory_draughting_callout = Rule() + +#################### + # RULE restrict_multi_language_for_organization_role # +#################### +restrict_multi_language_for_organization_role = Rule() + +#################### + # RULE restrict_multi_language_for_product_definition_formation_relationship # +#################### +restrict_multi_language_for_product_definition_formation_relationship = Rule() + +#################### + # RULE restrict_multi_language_for_uncertainty_measure_with_unit # +#################### +restrict_multi_language_for_uncertainty_measure_with_unit = Rule() + +#################### + # RULE restrict_viewing_plane_usage # +#################### +restrict_viewing_plane_usage = Rule() + +#################### + # RULE subtype_exclusiveness_identification_assignment # +#################### +subtype_exclusiveness_identification_assignment = Rule() + +#################### + # RULE subtype_mandatory_pre_defined_colour # +#################### +subtype_mandatory_pre_defined_colour = Rule() + +#################### + # RULE restrict_multi_language_for_configuration_item # +#################### +restrict_multi_language_for_configuration_item = Rule() + +#################### + # RULE restrict_class_system_assignment_for_class # +#################### +restrict_class_system_assignment_for_class = Rule() + +#################### + # RULE restrict_multi_language_for_pair_actuator # +#################### +restrict_multi_language_for_pair_actuator = Rule() + +#################### + # RULE restrict_product_definitions_for_product_definition_relationship # +#################### +restrict_product_definitions_for_product_definition_relationship = Rule() + +#################### + # RULE subtype_exclusiveness_symbol_representation # +#################### +subtype_exclusiveness_symbol_representation = Rule() + +#################### + # RULE dependent_instantiable_time_interval_role # +#################### +dependent_instantiable_time_interval_role = Rule() + +#################### + # RULE executed_action_requires_action_status # +#################### +executed_action_requires_action_status = Rule() + +#################### + # RULE consistent_uncertainty # +#################### +consistent_uncertainty = Rule() + +#################### + # RULE restrict_multi_language_for_application_context # +#################### +restrict_multi_language_for_application_context = Rule() + +#################### + # RULE restrict_multi_language_for_assembly_component_usage_substitute # +#################### +restrict_multi_language_for_assembly_component_usage_substitute = Rule() + +#################### + # RULE restrict_properties_of_document_representation # +#################### +restrict_properties_of_document_representation = Rule() + +#################### + # RULE security_classification_requires_security_classification_assignment # +#################### +security_classification_requires_security_classification_assignment = Rule() + +#################### + # RULE dependent_instantiable_fill_area_style_colour # +#################### +dependent_instantiable_fill_area_style_colour = Rule() + +#################### + # RULE dependent_instantiable_uncertainty_qualifier # +#################### +dependent_instantiable_uncertainty_qualifier = Rule() + +#################### + # RULE restrict_multi_language_for_certification # +#################### +restrict_multi_language_for_certification = Rule() + +#################### + # RULE restrict_multi_language_for_draughting_title # +#################### +restrict_multi_language_for_draughting_title = Rule() + +#################### + # RULE dependent_instantiable_product_definition_context_role # +#################### +dependent_instantiable_product_definition_context_role = Rule() + +#################### + # RULE dependent_instantiable_standard_uncertainty # +#################### +dependent_instantiable_standard_uncertainty = Rule() + +#################### + # RULE product_definition_replacement_requires_effectivity_assignment # +#################### +product_definition_replacement_requires_effectivity_assignment = Rule() + +#################### + # RULE restrict_name_assignment_for_kinematic_joint # +#################### +restrict_name_assignment_for_kinematic_joint = Rule() + +#################### + # RULE restrict_multi_language_for_group # +#################### +restrict_multi_language_for_group = Rule() + +#################### + # RULE dependent_instantiable_type_qualifier # +#################### +dependent_instantiable_type_qualifier = Rule() + +#################### + # RULE subtype_mandatory_configurable_item # +#################### +subtype_mandatory_configurable_item = Rule() + +#################### + # RULE restrict_multi_language_for_product_concept_feature # +#################### +restrict_multi_language_for_product_concept_feature = Rule() + +#################### + # RULE dependent_instantiable_identification_role # +#################### +dependent_instantiable_identification_role = Rule() + +#################### + # RULE restrict_product_categories_for_tool_part_relationship # +#################### +restrict_product_categories_for_tool_part_relationship = Rule() + +#################### + # RULE restrict_effectivity_usage # +#################### +restrict_effectivity_usage = Rule() + +#################### + # RULE restrict_multi_language_for_organizational_project_relationship # +#################### +restrict_multi_language_for_organizational_project_relationship = Rule() + +#################### + # RULE dependent_instantiable_date_time_role # +#################### +dependent_instantiable_date_time_role = Rule() + +#################### + # RULE dependent_instantiable_date_role # +#################### +dependent_instantiable_date_role = Rule() + +#################### + # RULE subtype_exclusiveness_colour # +#################### +subtype_exclusiveness_colour = Rule() + +#################### + # RULE subtype_exclusiveness_shape_representation_geometry # +#################### +subtype_exclusiveness_shape_representation_geometry = Rule() + +#################### + # RULE dependent_instantiable_text_style # +#################### +dependent_instantiable_text_style = Rule() + +#################### + # RULE dimensionality_is_two_or_three # +#################### +dimensionality_is_two_or_three = Rule() + +#################### + # RULE restrict_multi_language_for_product_definition # +#################### +restrict_multi_language_for_product_definition = Rule() + +#################### + # RULE subtype_exclusiveness_classification_assignment # +#################### +subtype_exclusiveness_classification_assignment = Rule() + +#################### + # RULE approval_person_organization_requires_date_time # +#################### +approval_person_organization_requires_date_time = Rule() + +#################### + # RULE restrict_group_relationship_for_general_classification_hierarchy # +#################### +restrict_group_relationship_for_general_classification_hierarchy = Rule() + +#################### + # RULE subtype_exclusiveness_shape_aspect # +#################### +subtype_exclusiveness_shape_aspect = Rule() + +#################### + # RULE event_occurrence_requires_event_occurrence_assignment # +#################### +event_occurrence_requires_event_occurrence_assignment = Rule() + +#################### + # RULE restrict_multi_language_for_topological_representation_item # +#################### +restrict_multi_language_for_topological_representation_item = Rule() + +#################### + # RULE subtype_exclusiveness_property_definition # +#################### +subtype_exclusiveness_property_definition = Rule() + +#################### + # RULE subtype_exclusiveness_pre_defined_item # +#################### +subtype_exclusiveness_pre_defined_item = Rule() + +#################### + # RULE restrict_multi_language_for_effectivity_relationship # +#################### +restrict_multi_language_for_effectivity_relationship = Rule() + +#################### + # RULE restrict_multi_language_for_action # +#################### +restrict_multi_language_for_action = Rule() + +#################### + # RULE restrict_multi_language_for_name_assignment # +#################### +restrict_multi_language_for_name_assignment = Rule() + +#################### + # RULE restrict_version_assignment_for_general_property # +#################### +restrict_version_assignment_for_general_property = Rule() + +#################### + # RULE restrict_multi_language_for_shape_aspect_relationship # +#################### +restrict_multi_language_for_shape_aspect_relationship = Rule() + +#################### + # RULE subtype_mandatory_pre_defined_item # +#################### +subtype_mandatory_pre_defined_item = Rule() + +#################### + # RULE restrict_applied_classification_assignment_role # +#################### +restrict_applied_classification_assignment_role = Rule() + +#################### + # RULE dependent_instantiable_event_occurrence_role # +#################### +dependent_instantiable_event_occurrence_role = Rule() + +#################### + # RULE full_model_change_completeness_for_action_property # +#################### +full_model_change_completeness_for_action_property = Rule() + +#################### + # RULE restrict_multi_language_for_external_source # +#################### +restrict_multi_language_for_external_source = Rule() + +#################### + # RULE restrict_multi_language_for_general_property_relationship # +#################### +restrict_multi_language_for_general_property_relationship = Rule() + +#################### + # RULE restrict_multi_language_for_general_property # +#################### +restrict_multi_language_for_general_property = Rule() + +#################### + # RULE restrict_multi_language_for_product # +#################### +restrict_multi_language_for_product = Rule() + +#################### + # RULE restrict_treatment_result # +#################### +restrict_treatment_result = Rule() + +#################### + # RULE dependent_instantiable_organizational_project_role # +#################### +dependent_instantiable_organizational_project_role = Rule() + +#################### + # RULE compound_features_of_equal_type # +#################### +compound_features_of_equal_type = Rule() + +#################### + # RULE restrict_product_definition_context_for_product # +#################### +restrict_product_definition_context_for_product = Rule() + +#################### + # RULE restrict_concept_feature_operator # +#################### +restrict_concept_feature_operator = Rule() + +#################### + # RULE dependent_instantiable_presentation_style_by_context # +#################### +dependent_instantiable_presentation_style_by_context = Rule() + +#################### + # RULE dependent_instantiable_pre_defined_symbol # +#################### +dependent_instantiable_pre_defined_symbol = Rule() + +#################### + # RULE restrict_version_assignment_for_action # +#################### +restrict_version_assignment_for_action = Rule() + +#################### + # RULE restrict_multi_language_for_resource_property # +#################### +restrict_multi_language_for_resource_property = Rule() + +#################### + # RULE physical_instance_requires_product_definition # +#################### +physical_instance_requires_product_definition = Rule() + +#################### + # RULE restrict_part_occurrence # +#################### +restrict_part_occurrence = Rule() + +#################### + # RULE restrict_default_settings # +#################### +restrict_default_settings = Rule() + +#################### + # RULE dependent_instantiable_symbol_colour # +#################### +dependent_instantiable_symbol_colour = Rule() + +#################### + # RULE design_constraint_requires_product_definition # +#################### +design_constraint_requires_product_definition = Rule() + +#################### + # RULE draughting_subfigure_representation_layers # +#################### +draughting_subfigure_representation_layers = Rule() + +#################### + # RULE restrict_multi_language_for_descriptive_representation_item # +#################### +restrict_multi_language_for_descriptive_representation_item = Rule() + +#################### + # RULE restrict_drawing # +#################### +restrict_drawing = Rule() + +#################### + # RULE full_model_change_completeness_for_property_definition # +#################### +full_model_change_completeness_for_property_definition = Rule() + +#################### + # RULE restrict_multi_language_for_process_product_association # +#################### +restrict_multi_language_for_process_product_association = Rule() + +#################### + # RULE dependent_instantiable_classification_role # +#################### +dependent_instantiable_classification_role = Rule() + +#################### + # RULE dependent_instantiable_derived_unit # +#################### +dependent_instantiable_derived_unit = Rule() + +#################### + # RULE subtype_exclusiveness_feature_component_relationship # +#################### +subtype_exclusiveness_feature_component_relationship = Rule() + +#################### + # RULE restrict_multi_language_for_resource_requirement_type # +#################### +restrict_multi_language_for_resource_requirement_type = Rule() + +#################### + # RULE restrict_product_definition_substitute # +#################### +restrict_product_definition_substitute = Rule() + +#################### + # RULE restrict_version_assignment_for_effectivity # +#################### +restrict_version_assignment_for_effectivity = Rule() + +#################### + # RULE dependent_instantiable_tolerance_value # +#################### +dependent_instantiable_tolerance_value = Rule() + +#################### + # RULE externally_defined_class_with_known_source_requirement # +#################### +externally_defined_class_with_known_source_requirement = Rule() + +#################### + # RULE restrict_default_thickness # +#################### +restrict_default_thickness = Rule() + +#################### + # RULE dependent_instantiable_action_directive # +#################### +dependent_instantiable_action_directive = Rule() + +#################### + # RULE subtype_exclusiveness_characterized_object # +#################### +subtype_exclusiveness_characterized_object = Rule() + +#################### + # RULE restrict_product_definition_context_for_external_properties # +#################### +restrict_product_definition_context_for_external_properties = Rule() + +#################### + # RULE drawing_sheet_layout_usage # +#################### +drawing_sheet_layout_usage = Rule() + +#################### + # RULE restrict_representation_for_document_properties # +#################### +restrict_representation_for_document_properties = Rule() + +#################### + # RULE plib_property_reference_requires_name_scope # +#################### +plib_property_reference_requires_name_scope = Rule() + +#################### + # RULE global_length_and_angle_units_2d_or_3d # +#################### +global_length_and_angle_units_2d_or_3d = Rule() + +#################### + # RULE subtype_exclusiveness_group # +#################### +subtype_exclusiveness_group = Rule() + +#################### + # RULE dependent_instantiable_action_resource_type # +#################### +dependent_instantiable_action_resource_type = Rule() + +#################### + # RULE dependent_instantiable_organization_role # +#################### +dependent_instantiable_organization_role = Rule() + +#################### + # RULE restrict_multi_language_for_date_role # +#################### +restrict_multi_language_for_date_role = Rule() + +#################### + # RULE restrict_multi_language_for_shape_aspect # +#################### +restrict_multi_language_for_shape_aspect = Rule() + +#################### + # RULE restrict_effectivity_assignment_for_class_category_usage # +#################### +restrict_effectivity_assignment_for_class_category_usage = Rule() + +#################### + # RULE dependent_instantiable_contract_type # +#################### +dependent_instantiable_contract_type = Rule() + +#################### + # RULE restrict_product_category_for_product # +#################### +restrict_product_category_for_product = Rule() + +#################### + # RULE styled_curve # +#################### +styled_curve = Rule() + +#################### + # RULE restrict_action_resource_requirement_for_process_operation # +#################### +restrict_action_resource_requirement_for_process_operation = Rule() + +#################### + # RULE subtype_exclusiveness_representation_item # +#################### +subtype_exclusiveness_representation_item = Rule() + +#################### + # RULE dependent_instantiable_effectivity_context_role # +#################### +dependent_instantiable_effectivity_context_role = Rule() + +#################### + # RULE plib_class_reference_requires_version # +#################### +plib_class_reference_requires_version = Rule() + +#################### + # RULE restrict_version_assignment_for_shape_representation # +#################### +restrict_version_assignment_for_shape_representation = Rule() + +#################### + # RULE subtype_exclusiveness_founded_item # +#################### +subtype_exclusiveness_founded_item = Rule() + +#################### + # RULE text_font_usage # +#################### +text_font_usage = Rule() + +#################### + # RULE subtype_exclusiveness_representation_map # +#################### +subtype_exclusiveness_representation_map = Rule() + +#################### + # RULE subtype_mandatory_pre_defined_symbol # +#################### +subtype_mandatory_pre_defined_symbol = Rule() + +#################### + # RULE restrict_class_system_assignment_for_security_classification_level # +#################### +restrict_class_system_assignment_for_security_classification_level = Rule() + +#################### + # RULE restrict_multi_language_for_action_directive # +#################### +restrict_multi_language_for_action_directive = Rule() + +#################### + # RULE subtype_mandatory_address # +#################### +subtype_mandatory_address = Rule() + +#################### + # RULE dependent_instantiable_document_usage_role # +#################### +dependent_instantiable_document_usage_role = Rule() + +#################### + # RULE dependent_instantiable_text_style_for_defined_font # +#################### +dependent_instantiable_text_style_for_defined_font = Rule() + +#################### + # RULE restrict_multi_language_for_product_concept_feature_association # +#################### +restrict_multi_language_for_product_concept_feature_association = Rule() + +#################### + # RULE subtype_exclusiveness_representation_relationship_with_transformation # +#################### +subtype_exclusiveness_representation_relationship_with_transformation = Rule() + +#################### + # RULE subtype_mandatory_colour_specification # +#################### +subtype_mandatory_colour_specification = Rule() + +#################### + # RULE restrict_name_assignment_for_kinematic_structure # +#################### +restrict_name_assignment_for_kinematic_structure = Rule() + +#################### + # RULE restrict_representation_for_document_size_property # +#################### +restrict_representation_for_document_size_property = Rule() + +#################### + # RULE subtype_exclusiveness_presentation_representation # +#################### +subtype_exclusiveness_presentation_representation = Rule() + +#################### + # RULE restrict_version_assignment_for_product_concept # +#################### +restrict_version_assignment_for_product_concept = Rule() + +#################### + # RULE fill_area_style_tile_symbol_constraint # +#################### +fill_area_style_tile_symbol_constraint = Rule() + +#################### + # RULE restrict_multi_language_for_property_definition_relationship # +#################### +restrict_multi_language_for_property_definition_relationship = Rule() + +#################### + # RULE subtype_exclusiveness_compound_representation_item # +#################### +subtype_exclusiveness_compound_representation_item = Rule() + +#################### + # RULE subtype_mandatory_pre_defined_curve_font # +#################### +subtype_mandatory_pre_defined_curve_font = Rule() + +#################### + # RULE dependent_instantiable_measure_with_unit # +#################### +dependent_instantiable_measure_with_unit = Rule() + +#################### + # RULE restrict_representation_for_document_creation_property # +#################### +restrict_representation_for_document_creation_property = Rule() + +#################### + # RULE dependent_instantiable_colour_rgb # +#################### +dependent_instantiable_colour_rgb = Rule() + +#################### + # RULE restrict_multi_language_for_mapped_item # +#################### +restrict_multi_language_for_mapped_item = Rule() + +#################### + # RULE restrict_multi_language_for_presentation_layer_assignment # +#################### +restrict_multi_language_for_presentation_layer_assignment = Rule() + +#################### + # RULE restrict_multi_language_for_product_concept_relationship # +#################### +restrict_multi_language_for_product_concept_relationship = Rule() + +#################### + # RULE restrict_multi_language_for_versioned_action_request # +#################### +restrict_multi_language_for_versioned_action_request = Rule() + +#################### + # RULE dependent_instantiable_date # +#################### +dependent_instantiable_date = Rule() + +#################### + # RULE restrict_version_assignment_for_configuration_item # +#################### +restrict_version_assignment_for_configuration_item = Rule() + +#################### + # RULE restrict_representation_item_for_hybrid_geometric_model_3d # +#################### +restrict_representation_item_for_hybrid_geometric_model_3d = Rule() + +#################### + # RULE restrict_multi_language_for_contract # +#################### +restrict_multi_language_for_contract = Rule() + +#################### + # RULE restrict_multi_language_for_configuration_design # +#################### +restrict_multi_language_for_configuration_design = Rule() + +#################### + # RULE subtype_exclusiveness_document_reference # +#################### +subtype_exclusiveness_document_reference = Rule() + +#################### + # RULE restrict_multi_language_for_versioned_action_request_relationship # +#################### +restrict_multi_language_for_versioned_action_request_relationship = Rule() + +#################### + # RULE restrict_version_assignment_for_draughting_model # +#################### +restrict_version_assignment_for_draughting_model = Rule() + +#################### + # RULE subtype_exclusiveness_shape_aspect_relationship # +#################### +subtype_exclusiveness_shape_aspect_relationship = Rule() + +#################### + # RULE dependent_instantiable_precision_qualifier # +#################### +dependent_instantiable_precision_qualifier = Rule() + +#################### + # RULE restrict_approval # +#################### +restrict_approval = Rule() + +#################### + # RULE subtype_mandatory_document_product_association # +#################### +subtype_mandatory_document_product_association = Rule() + +#################### + # RULE restrict_group_relationship_for_specification_category # +#################### +restrict_group_relationship_for_specification_category = Rule() + +#################### + # RULE restrict_multi_language_for_product_concept # +#################### +restrict_multi_language_for_product_concept = Rule() + +#################### + # RULE restrict_multi_language_for_uncertainty_qualifier # +#################### +restrict_multi_language_for_uncertainty_qualifier = Rule() + +#################### + # RULE restrict_externally_defined_item_relationship # +#################### +restrict_externally_defined_item_relationship = Rule() + +#################### + # RULE restrict_representation_for_surface_condition # +#################### +restrict_representation_for_surface_condition = Rule() + +#################### + # RULE subtype_mandatory_camera_model # +#################### +subtype_mandatory_camera_model = Rule() + +#################### + # RULE restrict_applied_action_request_assignment # +#################### +restrict_applied_action_request_assignment = Rule() + +#################### + # RULE restrict_version_assignment_for_product_concept_feature # +#################### +restrict_version_assignment_for_product_concept_feature = Rule() + +#################### + # RULE subtype_exclusiveness_property_definition_representation # +#################### +subtype_exclusiveness_property_definition_representation = Rule() + +#################### + # RULE subtype_exclusiveness_representation_relationship # +#################### +subtype_exclusiveness_representation_relationship = Rule() + +#################### + # RULE sheets_belong_to_one_drawing # +#################### +sheets_belong_to_one_drawing = Rule() + +#################### + # RULE restrict_multi_language_for_representation_relationship # +#################### +restrict_multi_language_for_representation_relationship = Rule() + +#################### + # RULE dependent_instantiable_approval_role # +#################### +dependent_instantiable_approval_role = Rule() + +#################### + # RULE restrict_version_assignment_for_class # +#################### +restrict_version_assignment_for_class = Rule() + +#################### + # RULE subtype_exclusiveness_externally_defined_item # +#################### +subtype_exclusiveness_externally_defined_item = Rule() + +#################### + # RULE complex_product_requires_product_definition # +#################### +complex_product_requires_product_definition = Rule() + +#################### + # RULE restrict_multi_language_for_styled_item # +#################### +restrict_multi_language_for_styled_item = Rule() + +#################### + # RULE subtype_exclusiveness_transition_feature # +#################### +subtype_exclusiveness_transition_feature = Rule() + +#################### + # RULE restrict_properties_of_document_file # +#################### +restrict_properties_of_document_file = Rule() + +#################### + # RULE restrict_class_system_assignment_for_descriptive_representation_item # +#################### +restrict_class_system_assignment_for_descriptive_representation_item = Rule() + +#################### + # RULE restrict_representation_for_document_format_property # +#################### +restrict_representation_for_document_format_property = Rule() + +#################### + # RULE dependent_instantiable_object_role # +#################### +dependent_instantiable_object_role = Rule() + +#################### + # RULE restrict_applied_organizational_project_assignment # +#################### +restrict_applied_organizational_project_assignment = Rule() + +#################### + # RULE restrict_multi_language_for_group_relationship # +#################### +restrict_multi_language_for_group_relationship = Rule() + +#################### + # RULE dependent_instantiable_attribute_value_role # +#################### +dependent_instantiable_attribute_value_role = Rule() + +#################### + # RULE drawing_view_annotation_layers # +#################### +drawing_view_annotation_layers = Rule() + +#################### + # RULE subtype_mandatory_geometric_tolerance # +#################### +subtype_mandatory_geometric_tolerance = Rule() + +#################### + # RULE product_concept_feature_requires_category # +#################### +product_concept_feature_requires_category = Rule() + +#################### + # RULE restrict_version_assignment_for_presentation_area # +#################### +restrict_version_assignment_for_presentation_area = Rule() + +#################### + # RULE terminator_symbol_constraint # +#################### +terminator_symbol_constraint = Rule() + +#################### + # RULE dependent_instantiable_pre_defined_colour # +#################### +dependent_instantiable_pre_defined_colour = Rule() + +#################### + # RULE restrict_multi_language_for_event_occurrence # +#################### +restrict_multi_language_for_event_occurrence = Rule() + +#################### + # RULE restrict_effectivity_for_effectivity_relationship # +#################### +restrict_effectivity_for_effectivity_relationship = Rule() + +#################### + # RULE restrict_applied_event_occurrence_assignment # +#################### +restrict_applied_event_occurrence_assignment = Rule() + +#################### + # RULE restrict_applied_action_assignment # +#################### +restrict_applied_action_assignment = Rule() + +#################### + # RULE presentation_view_presented_once # +#################### +presentation_view_presented_once = Rule() + +#################### + # RULE dependent_instantiable_resource_requirement_type # +#################### +dependent_instantiable_resource_requirement_type = Rule() + +#################### + # RULE restrict_multi_language_for_geometric_representation_item # +#################### +restrict_multi_language_for_geometric_representation_item = Rule() + +#################### + # RULE coordinated_assembly_and_shape # +#################### +coordinated_assembly_and_shape = Rule() + +#################### + # RULE restrict_multi_language_for_date_time_role # +#################### +restrict_multi_language_for_date_time_role = Rule() + +#################### + # RULE restrict_multi_language_for_requirement_for_action_resource # +#################### +restrict_multi_language_for_requirement_for_action_resource = Rule() + +#################### + # RULE restrict_version_assignment_for_applied_identification_assignment # +#################### +restrict_version_assignment_for_applied_identification_assignment = Rule() + +#################### + # RULE approval_requires_approval_assignment # +#################### +approval_requires_approval_assignment = Rule() + +#################### + # RULE plib_property_reference_requires_version # +#################### +plib_property_reference_requires_version = Rule() + +#################### + # RULE restrict_version_assignment_for_action_method # +#################### +restrict_version_assignment_for_action_method = Rule() + +#################### + # RULE dependent_instantiable_fill_area_style # +#################### +dependent_instantiable_fill_area_style = Rule() + +#################### + # RULE subtype_exclusiveness_representation # +#################### +subtype_exclusiveness_representation = Rule() + +#################### + # RULE product_requires_category # +#################### +product_requires_category = Rule() + +#################### + # RULE subtype_mandatory_camera_image # +#################### +subtype_mandatory_camera_image = Rule() + +#################### + # RULE presentation_layer_assignment_constraint_2d_or_3d # +#################### +presentation_layer_assignment_constraint_2d_or_3d = Rule() + +#################### + # RULE restrict_class_system_assignment_for_approval_status # +#################### +restrict_class_system_assignment_for_approval_status = Rule() + +#################### + # RULE restrict_name_for_known_source # +#################### +restrict_name_for_known_source = Rule() + +#################### + # RULE dependent_instantiable_externally_defined_symbol # +#################### +dependent_instantiable_externally_defined_symbol = Rule() + +#################### + # RULE restrict_class_system_assignment_for_document_type # +#################### +restrict_class_system_assignment_for_document_type = Rule() + +#################### + # RULE restrict_multi_language_for_data_environment # +#################### +restrict_multi_language_for_data_environment = Rule() diff --git a/src/Mod/Import/App/ifc2x3.py b/src/Mod/Import/App/ifc2x3.py new file mode 100644 index 000000000..64d5b94be --- /dev/null +++ b/src/Mod/Import/App/ifc2x3.py @@ -0,0 +1,37012 @@ +# This file was generated by fedex_python. You probably don't want to edit +# it since your modifications will be lost if fedex_plus is used to +# regenerate it. +import sys + +from SCL.SCLBase import * +from SCL.SimpleDataTypes import * +from SCL.ConstructedDataTypes import * +from SCL.AggregationDataTypes import * +from SCL.TypeChecker import check_type +from SCL.Builtin import * +from SCL.Rules import * + +schema_name = 'ifc2x3' + +schema_scope = sys.modules[__name__] + +# Defined datatype ifcstructuralsurfacetypeenum +class ifcstructuralsurfacetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcloadgrouptypeenum +class ifcloadgrouptypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmodulusoflinearsubgradereactionmeasure +class ifcmodulusoflinearsubgradereactionmeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifchatchlinedistanceselect +ifchatchlinedistanceselect = SELECT( + 'ifconedirectionrepeatfactor', + 'ifcpositivelengthmeasure', + scope = schema_scope) +# SELECT TYPE ifcshell +ifcshell = SELECT( + 'ifcclosedshell', + 'ifcopenshell', + scope = schema_scope) +# Defined datatype ifcprotectivedevicetypeenum +class ifcprotectivedevicetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclinearforcemeasure +class ifclinearforcemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcassemblyplaceenum +class ifcassemblyplaceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcroleenum +class ifcroleenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcribplatedirectionenum +class ifcribplatedirectionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsoundpowermeasure +class ifcsoundpowermeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsiunitname +class ifcsiunitname(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcairtoairheatrecoverytypeenum +class ifcairtoairheatrecoverytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcanalysistheorytypeenum +class ifcanalysistheorytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcchangeactionenum +class ifcchangeactionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoorpaneloperationenum +class ifcdoorpaneloperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowpaneloperationenum +class ifcwindowpaneloperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcslabtypeenum +class ifcslabtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricconductancemeasure +class ifcelectricconductancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifckinematicviscositymeasure +class ifckinematicviscositymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclinearvelocitymeasure +class ifclinearvelocitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctimemeasure +class ifctimemeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcfillstyleselect +ifcfillstyleselect = SELECT( + 'ifcfillareastylehatching', + 'ifcfillareastyletiles', + 'ifccolour', + 'ifcexternallydefinedhatchstyle', + scope = schema_scope) +# SELECT TYPE ifcstructuralactivityassignmentselect +ifcstructuralactivityassignmentselect = SELECT( + 'ifcstructuralitem', + 'ifcelement', + scope = schema_scope) +# Defined datatype ifcreflectancemethodenum +class ifcreflectancemethodenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctransformertypeenum +class ifctransformertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccsgselect +ifccsgselect = SELECT( + 'ifcbooleanresult', + 'ifccsgprimitive3d', + scope = schema_scope) +# SELECT TYPE ifcmaterialselect +ifcmaterialselect = SELECT( + 'ifcmaterial', + 'ifcmateriallist', + 'ifcmateriallayersetusage', + 'ifcmateriallayerset', + 'ifcmateriallayer', + scope = schema_scope) +# SELECT TYPE ifcdraughtingcalloutelement +ifcdraughtingcalloutelement = SELECT( + 'ifcannotationcurveoccurrence', + 'ifcannotationtextoccurrence', + 'ifcannotationsymboloccurrence', + scope = schema_scope) +# Defined datatype ifcelectriccapacitancemeasure +class ifcelectriccapacitancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfrequencymeasure +class ifcfrequencymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcidentifier +class ifcidentifier(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdirectionsenseenum +class ifcdirectionsenseenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcvalue +ifcvalue = SELECT( + 'ifcmeasurevalue', + 'ifcsimplevalue', + 'ifcderivedmeasurevalue', + scope = schema_scope) +# Defined datatype ifcductsilencertypeenum +class ifcductsilencertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclabel +class ifclabel(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcactionsourcetypeenum +class ifcactionsourcetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctendontypeenum +class ifctendontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpressuremeasure +class ifcpressuremeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctransitioncode +class ifctransitioncode(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcenvironmentalimpactcategoryenum +class ifcenvironmentalimpactcategoryenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctextalignment +class ifctextalignment(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['left','right','center','justify']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcthermalresistancemeasure +class ifcthermalresistancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricmotortypeenum +class ifcelectricmotortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctanktypeenum +class ifctanktypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcforcemeasure +class ifcforcemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcheatexchangertypeenum +class ifcheatexchangertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccoiltypeenum +class ifccoiltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrotationalmassmeasure +class ifcrotationalmassmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectriccurrentenum +class ifcelectriccurrentenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctimeseriesscheduletypeenum +class ifctimeseriesscheduletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsectionalareaintegralmeasure +class ifcsectionalareaintegralmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclengthmeasure +class ifclengthmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowpanelpositionenum +class ifcwindowpanelpositionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcluminousintensitydistributionmeasure +class ifcluminousintensitydistributionmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrotationalstiffnessmeasure +class ifcrotationalstiffnessmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcanalysismodeltypeenum +class ifcanalysismodeltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsoundpressuremeasure +class ifcsoundpressuremeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccolour +ifccolour = SELECT( + 'ifccolourspecification', + 'ifcpredefinedcolour', + scope = schema_scope) +# Defined datatype ifcspecularroughness +class ifcspecularroughness(REAL): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self <= 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE ifcappliedvalueselect +ifcappliedvalueselect = SELECT( + 'ifcratiomeasure', + 'ifcmeasurewithunit', + 'ifcmonetarymeasure', + scope = schema_scope) +# SELECT TYPE ifcclassificationnotationselect +ifcclassificationnotationselect = SELECT( + 'ifcclassificationnotation', + 'ifcclassificationreference', + scope = schema_scope) +# Defined datatype ifcproceduretypeenum +class ifcproceduretypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcheatingvaluemeasure +class ifcheatingvaluemeasure(REAL): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcinductancemeasure +class ifcinductancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccurtainwalltypeenum +class ifccurtainwalltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmassperlengthmeasure +class ifcmassperlengthmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcthermalloadsourceenum +class ifcthermalloadsourceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifctextstyleselect +ifctextstyleselect = SELECT( + 'ifctextstylewithboxcharacteristics', + 'ifctextstyletextmodel', + scope = schema_scope) +# Defined datatype ifctexttransformation +class ifctexttransformation(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['capitalize','uppercase','lowercase','none']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcactuatortypeenum +class ifcactuatortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifchumidifiertypeenum +class ifchumidifiertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcconnectiontypeenum +class ifcconnectiontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccontrollertypeenum +class ifccontrollertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricgeneratortypeenum +class ifcelectricgeneratortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwasteterminaltypeenum +class ifcwasteterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcshearmodulusmeasure +class ifcshearmodulusmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclamptypeenum +class ifclamptypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcpresentationstyleselect +ifcpresentationstyleselect = SELECT( + 'ifcnullstyle', + 'ifccurvestyle', + 'ifcsymbolstyle', + 'ifcfillareastyle', + 'ifctextstyle', + 'ifcsurfacestyle', + scope = schema_scope) +# Defined datatype ifcintegercountratemeasure +class ifcintegercountratemeasure(INTEGER): + def __init__(self,*kargs): + pass + +# Defined datatype ifcaddresstypeenum +class ifcaddresstypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcbenchmarkenum +class ifcbenchmarkenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcoccupanttypeenum +class ifcoccupanttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmassdensitymeasure +class ifcmassdensitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccablecarriersegmenttypeenum +class ifccablecarriersegmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifclightdistributiondatasourceselect +ifclightdistributiondatasourceselect = SELECT( + 'ifcexternalreference', + 'ifclightintensitydistribution', + scope = schema_scope) +# SELECT TYPE ifcunit +ifcunit = SELECT( + 'ifcderivedunit', + 'ifcnamedunit', + 'ifcmonetaryunit', + scope = schema_scope) +# Defined datatype ifcmodulusofelasticitymeasure +class ifcmodulusofelasticitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcairterminaltypeenum +class ifcairterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcpointorvertexpoint +ifcpointorvertexpoint = SELECT( + 'ifcpoint', + 'ifcvertexpoint', + scope = schema_scope) +# Defined datatype ifctransportelementtypeenum +class ifctransportelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelementassemblytypeenum +class ifcelementassemblytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdocumentstatusenum +class ifcdocumentstatusenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccurvefontorscaledcurvefontselect +ifccurvefontorscaledcurvefontselect = SELECT( + 'ifccurvestylefontselect', + 'ifccurvestylefontandscaling', + scope = schema_scope) +# Defined datatype ifcspecularexponent +class ifcspecularexponent(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifctextfontselect +ifctextfontselect = SELECT( + 'ifcpredefinedtextfont', + 'ifcexternallydefinedtextfont', + scope = schema_scope) +# Defined datatype ifcactiontypeenum +class ifcactiontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdynamicviscositymeasure +class ifcdynamicviscositymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclightemissionsourceenum +class ifclightemissionsourceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvolumemeasure +class ifcvolumemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcnullstyle +class ifcnullstyle(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcluminousintensitymeasure +class ifcluminousintensitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmodulusofrotationalsubgradereactionmeasure +class ifcmodulusofrotationalsubgradereactionmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcspaceheatertypeenum +class ifcspaceheatertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpiletypeenum +class ifcpiletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcstackterminaltypeenum +class ifcstackterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfiltertypeenum +class ifcfiltertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcprojectorderrecordtypeenum +class ifcprojectorderrecordtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcabsorbeddosemeasure +class ifcabsorbeddosemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclightdistributioncurveenum +class ifclightdistributioncurveenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcmetricvalueselect +ifcmetricvalueselect = SELECT( + 'ifcdatetimeselect', + 'ifcmeasurewithunit', + 'ifctable', + 'ifctext', + 'ifctimeseries', + 'ifccostvalue', + scope = schema_scope) +# Defined datatype ifcobjecttypeenum +class ifcobjecttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfantypeenum +class ifcfantypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcgeometricprojectionenum +class ifcgeometricprojectionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctrimmingpreference +class ifctrimmingpreference(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcinternalorexternalenum +class ifcinternalorexternalenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcthermodynamictemperaturemeasure +class ifcthermodynamictemperaturemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsurfaceside +class ifcsurfaceside(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricvoltagemeasure +class ifcelectricvoltagemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowstyleconstructionenum +class ifcwindowstyleconstructionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcductfittingtypeenum +class ifcductfittingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctubebundletypeenum +class ifctubebundletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccountmeasure +class ifccountmeasure(NUMBER): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrailingtypeenum +class ifcrailingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcswitchingdevicetypeenum +class ifcswitchingdevicetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcaccelerationmeasure +class ifcaccelerationmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccurvaturemeasure +class ifccurvaturemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcplaneanglemeasure +class ifcplaneanglemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricheatertypeenum +class ifcelectricheatertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsurfaceorfacesurface +ifcsurfaceorfacesurface = SELECT( + 'ifcsurface', + 'ifcfacesurface', + 'ifcfacebasedsurfacemodel', + scope = schema_scope) +# Defined datatype ifclogicaloperatorenum +class ifclogicaloperatorenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcmeasurevalue +ifcmeasurevalue = SELECT( + 'ifcvolumemeasure', + 'ifctimemeasure', + 'ifcthermodynamictemperaturemeasure', + 'ifcsolidanglemeasure', + 'ifcpositiveratiomeasure', + 'ifcratiomeasure', + 'ifcpositiveplaneanglemeasure', + 'ifcplaneanglemeasure', + 'ifcparametervalue', + 'ifcnumericmeasure', + 'ifcmassmeasure', + 'ifcpositivelengthmeasure', + 'ifclengthmeasure', + 'ifcelectriccurrentmeasure', + 'ifcdescriptivemeasure', + 'ifccountmeasure', + 'ifccontextdependentmeasure', + 'ifcareameasure', + 'ifcamountofsubstancemeasure', + 'ifcluminousintensitymeasure', + 'ifcnormalisedratiomeasure', + 'ifccomplexnumber', + scope = schema_scope) +# SELECT TYPE ifclibraryselect +ifclibraryselect = SELECT( + 'ifclibraryreference', + 'ifclibraryinformation', + scope = schema_scope) +# Defined datatype ifcparametervalue +class ifcparametervalue(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcthermalconductivitymeasure +class ifcthermalconductivitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcgasterminaltypeenum +class ifcgasterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsectiontypeenum +class ifcsectiontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcplanarforcemeasure +class ifcplanarforcemeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcgeometricsetselect +ifcgeometricsetselect = SELECT( + 'ifcpoint', + 'ifccurve', + 'ifcsurface', + scope = schema_scope) +# Defined datatype ifcareameasure +class ifcareameasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccontextdependentmeasure +class ifccontextdependentmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctextfontname +class ifctextfontname(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifclogical +class ifclogical(LOGICAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcorientationselect +ifcorientationselect = SELECT( + 'ifcplaneanglemeasure', + 'ifcdirection', + scope = schema_scope) +# Defined datatype ifcthermaladmittancemeasure +class ifcthermaladmittancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcspacetypeenum +class ifcspacetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoseequivalentmeasure +class ifcdoseequivalentmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmolecularweightmeasure +class ifcmolecularweightmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcenergysequenceenum +class ifcenergysequenceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcobjectreferenceselect +ifcobjectreferenceselect = SELECT( + 'ifcmaterial', + 'ifcperson', + 'ifcdateandtime', + 'ifcmateriallist', + 'ifcorganization', + 'ifccalendardate', + 'ifclocaltime', + 'ifcpersonandorganization', + 'ifcmateriallayer', + 'ifcexternalreference', + 'ifctimeseries', + 'ifcaddress', + 'ifcappliedvalue', + scope = schema_scope) +# Defined datatype ifcpowermeasure +class ifcpowermeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccurveoredgecurve +ifccurveoredgecurve = SELECT( + 'ifcboundedcurve', + 'ifcedgecurve', + scope = schema_scope) +# Defined datatype ifccoveringtypeenum +class ifccoveringtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcunitaryequipmenttypeenum +class ifcunitaryequipmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcaxis2placement +ifcaxis2placement = SELECT( + 'ifcaxis2placement2d', + 'ifcaxis2placement3d', + scope = schema_scope) +# Defined datatype ifcbooleanoperator +class ifcbooleanoperator(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccostscheduletypeenum +class ifccostscheduletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpileconstructionenum +class ifcpileconstructionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcderivedunitenum +class ifcderivedunitenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricflowstoragedevicetypeenum +class ifcelectricflowstoragedevicetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclightfixturetypeenum +class ifclightfixturetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfontstyle +class ifcfontstyle(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['normal','italic','oblique']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE ifctrimmingselect +ifctrimmingselect = SELECT( + 'ifccartesianpoint', + 'ifcparametervalue', + scope = schema_scope) +# Defined datatype ifcamountofsubstancemeasure +class ifcamountofsubstancemeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsizeselect +ifcsizeselect = SELECT( + 'ifcratiomeasure', + 'ifclengthmeasure', + 'ifcdescriptivemeasure', + 'ifcpositivelengthmeasure', + 'ifcnormalisedratiomeasure', + 'ifcpositiveratiomeasure', + scope = schema_scope) +# Defined datatype ifcbeamtypeenum +class ifcbeamtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccharacterstyleselect +ifccharacterstyleselect = SELECT( + 'ifctextstylefordefinedfont', + scope = schema_scope) +# Defined datatype ifcpropertysourceenum +class ifcpropertysourceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsoundscaleenum +class ifcsoundscaleenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpumptypeenum +class ifcpumptypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcboxalignment +class ifcboxalignment(ifclabel): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcelectricchargemeasure +class ifcelectricchargemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcminuteinhour +class ifcminuteinhour(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self <= 59)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcinventorytypeenum +class ifcinventorytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwarpingmomentmeasure +class ifcwarpingmomentmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcresourceconsumptionenum +class ifcresourceconsumptionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctext +class ifctext(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcairterminalboxtypeenum +class ifcairterminalboxtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcderivedmeasurevalue +ifcderivedmeasurevalue = SELECT( + 'ifcvolumetricflowratemeasure', + 'ifctimestamp', + 'ifcthermaltransmittancemeasure', + 'ifcthermalresistancemeasure', + 'ifcthermaladmittancemeasure', + 'ifcpressuremeasure', + 'ifcpowermeasure', + 'ifcmassflowratemeasure', + 'ifcmassdensitymeasure', + 'ifclinearvelocitymeasure', + 'ifckinematicviscositymeasure', + 'ifcintegercountratemeasure', + 'ifcheatfluxdensitymeasure', + 'ifcfrequencymeasure', + 'ifcenergymeasure', + 'ifcelectricvoltagemeasure', + 'ifcdynamicviscositymeasure', + 'ifccompoundplaneanglemeasure', + 'ifcangularvelocitymeasure', + 'ifcthermalconductivitymeasure', + 'ifcmolecularweightmeasure', + 'ifcvaporpermeabilitymeasure', + 'ifcmoisturediffusivitymeasure', + 'ifcisothermalmoisturecapacitymeasure', + 'ifcspecificheatcapacitymeasure', + 'ifcmonetarymeasure', + 'ifcmagneticfluxdensitymeasure', + 'ifcmagneticfluxmeasure', + 'ifcluminousfluxmeasure', + 'ifcforcemeasure', + 'ifcinductancemeasure', + 'ifcilluminancemeasure', + 'ifcelectricresistancemeasure', + 'ifcelectricconductancemeasure', + 'ifcelectricchargemeasure', + 'ifcdoseequivalentmeasure', + 'ifcelectriccapacitancemeasure', + 'ifcabsorbeddosemeasure', + 'ifcradioactivitymeasure', + 'ifcrotationalfrequencymeasure', + 'ifctorquemeasure', + 'ifcaccelerationmeasure', + 'ifclinearforcemeasure', + 'ifclinearstiffnessmeasure', + 'ifcmodulusofsubgradereactionmeasure', + 'ifcmodulusofelasticitymeasure', + 'ifcmomentofinertiameasure', + 'ifcplanarforcemeasure', + 'ifcrotationalstiffnessmeasure', + 'ifcshearmodulusmeasure', + 'ifclinearmomentmeasure', + 'ifcluminousintensitydistributionmeasure', + 'ifccurvaturemeasure', + 'ifcmassperlengthmeasure', + 'ifcmodulusoflinearsubgradereactionmeasure', + 'ifcmodulusofrotationalsubgradereactionmeasure', + 'ifcrotationalmassmeasure', + 'ifcsectionalareaintegralmeasure', + 'ifcsectionmodulusmeasure', + 'ifctemperaturegradientmeasure', + 'ifcthermalexpansioncoefficientmeasure', + 'ifcwarpingconstantmeasure', + 'ifcwarpingmomentmeasure', + 'ifcsoundpowermeasure', + 'ifcsoundpressuremeasure', + 'ifcheatingvaluemeasure', + 'ifcphmeasure', + 'ifcionconcentrationmeasure', + scope = schema_scope) +# Defined datatype ifcreinforcingbarroleenum +class ifcreinforcingbarroleenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclinearstiffnessmeasure +class ifclinearstiffnessmeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccolourorfactor +ifccolourorfactor = SELECT( + 'ifccolourrgb', + 'ifcnormalisedratiomeasure', + scope = schema_scope) +# SELECT TYPE ifcvectorordirection +ifcvectorordirection = SELECT( + 'ifcdirection', + 'ifcvector', + scope = schema_scope) +# Defined datatype ifcisothermalmoisturecapacitymeasure +class ifcisothermalmoisturecapacitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricappliancetypeenum +class ifcelectricappliancetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcratiomeasure +class ifcratiomeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfootingtypeenum +class ifcfootingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcplatetypeenum +class ifcplatetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsimplevalue +ifcsimplevalue = SELECT( + 'ifcinteger', + 'ifcreal', + 'ifcboolean', + 'ifcidentifier', + 'ifctext', + 'ifclabel', + 'ifclogical', + scope = schema_scope) +# Defined datatype ifcinteger +class ifcinteger(INTEGER): + def __init__(self,*kargs): + pass + +# Defined datatype ifcthermalexpansioncoefficientmeasure +class ifcthermalexpansioncoefficientmeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcdefinedsymbolselect +ifcdefinedsymbolselect = SELECT( + 'ifcpredefinedsymbol', + 'ifcexternallydefinedsymbol', + scope = schema_scope) +# Defined datatype ifcpositiveplaneanglemeasure +class ifcpositiveplaneanglemeasure(ifcplaneanglemeasure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifccooledbeamtypeenum +class ifccooledbeamtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcdatetimeselect +ifcdatetimeselect = SELECT( + 'ifccalendardate', + 'ifclocaltime', + 'ifcdateandtime', + scope = schema_scope) +# Defined datatype ifcdimensioncount +class ifcdimensioncount(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 < self) and (self <= 3)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcmassmeasure +class ifcmassmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdataoriginenum +class ifcdataoriginenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcphysicalorvirtualenum +class ifcphysicalorvirtualenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpermeablecoveringoperationenum +class ifcpermeablecoveringoperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcstairflighttypeenum +class ifcstairflighttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcjunctionboxtypeenum +class ifcjunctionboxtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctorquemeasure +class ifctorquemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcglobalorlocalenum +class ifcglobalorlocalenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmoisturediffusivitymeasure +class ifcmoisturediffusivitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdistributionchamberelementtypeenum +class ifcdistributionchamberelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctextpath +class ifctextpath(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcunitenum +class ifcunitenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricdistributionpointfunctionenum +class ifcelectricdistributionpointfunctionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvalvetypeenum +class ifcvalvetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpresentabletext +class ifcpresentabletext(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifccompressortypeenum +class ifccompressortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctimeseriesdatatypeenum +class ifctimeseriesdatatypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcspecularhighlightselect +ifcspecularhighlightselect = SELECT( + 'ifcspecularexponent', + 'ifcspecularroughness', + scope = schema_scope) +# Defined datatype ifcdayinmonthnumber +class ifcdayinmonthnumber(INTEGER): + def __init__(self,*kargs): + pass + +# Defined datatype ifcspecificheatcapacitymeasure +class ifcspecificheatcapacitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcenergymeasure +class ifcenergymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdimensionextentusage +class ifcdimensionextentusage(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectriccurrentmeasure +class ifcelectriccurrentmeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifclayereditem +ifclayereditem = SELECT( + 'ifcrepresentationitem', + 'ifcrepresentation', + scope = schema_scope) +# Defined datatype ifcluminousfluxmeasure +class ifcluminousfluxmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsensortypeenum +class ifcsensortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsequenceenum +class ifcsequenceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdescriptivemeasure +class ifcdescriptivemeasure(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelementcompositionenum +class ifcelementcompositionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcthermaltransmittancemeasure +class ifcthermaltransmittancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcreal +class ifcreal(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcconstraintenum +class ifcconstraintenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoorpanelpositionenum +class ifcdoorpanelpositionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcflowdirectionenum +class ifcflowdirectionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsiprefix +class ifcsiprefix(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcboilertypeenum +class ifcboilertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccurrencyenum +class ifccurrencyenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmagneticfluxdensitymeasure +class ifcmagneticfluxdensitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcservicelifefactortypeenum +class ifcservicelifefactortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccoolingtowertypeenum +class ifccoolingtowertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcboolean +class ifcboolean(BOOLEAN): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdaylightsavinghour +class ifcdaylightsavinghour(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self <= 2)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcbuildingelementproxytypeenum +class ifcbuildingelementproxytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcstructuralcurvetypeenum +class ifcstructuralcurvetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcangularvelocitymeasure +class ifcangularvelocitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmonetarymeasure +class ifcmonetarymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmonthinyearnumber +class ifcmonthinyearnumber(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((1 <= self) and (self <= 12)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcsectionmodulusmeasure +class ifcsectionmodulusmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoorstyleconstructionenum +class ifcdoorstyleconstructionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrooftypeenum +class ifcrooftypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsanitaryterminaltypeenum +class ifcsanitaryterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdocumentconfidentialityenum +class ifcdocumentconfidentialityenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfiresuppressionterminaltypeenum +class ifcfiresuppressionterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcradioactivitymeasure +class ifcradioactivitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsurfacetextureenum +class ifcsurfacetextureenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmomentofinertiameasure +class ifcmomentofinertiameasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwarpingconstantmeasure +class ifcwarpingconstantmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcheatfluxdensitymeasure +class ifcheatfluxdensitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvaporpermeabilitymeasure +class ifcvaporpermeabilitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsecondinminute +class ifcsecondinminute(REAL): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self < 60)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcvibrationisolatortypeenum +class ifcvibrationisolatortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcbooleanoperand +ifcbooleanoperand = SELECT( + 'ifcsolidmodel', + 'ifchalfspacesolid', + 'ifcbooleanresult', + 'ifccsgprimitive3d', + scope = schema_scope) +# Defined datatype ifcflowinstrumenttypeenum +class ifcflowinstrumenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfontvariant +class ifcfontvariant(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['normal','small-caps']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcprofiletypeenum +class ifcprofiletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcactorselect +ifcactorselect = SELECT( + 'ifcorganization', + 'ifcperson', + 'ifcpersonandorganization', + scope = schema_scope) +# Defined datatype ifcmagneticfluxmeasure +class ifcmagneticfluxmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcyearnumber +class ifcyearnumber(INTEGER): + def __init__(self,*kargs): + pass + +# Defined datatype ifcgloballyuniqueid +class ifcgloballyuniqueid(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcevaporativecoolertypeenum +class ifcevaporativecoolertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcaheadorbehind +class ifcaheadorbehind(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfontweight +class ifcfontweight(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['normal','small-caps','100','200','300','400','500','600','700','800','900']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcchillertypeenum +class ifcchillertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcalarmtypeenum +class ifcalarmtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccablecarrierfittingtypeenum +class ifccablecarrierfittingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcthermalloadtypeenum +class ifcthermalloadtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccolumntypeenum +class ifccolumntypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcprojectordertypeenum +class ifcprojectordertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcramptypeenum +class ifcramptypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcstateenum +class ifcstateenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpipesegmenttypeenum +class ifcpipesegmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifchourinday +class ifchourinday(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self < 24)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcnormalisedratiomeasure +class ifcnormalisedratiomeasure(ifcratiomeasure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self <= 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcreinforcingbarsurfaceenum +class ifcreinforcingbarsurfaceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpositivelengthmeasure +class ifcpositivelengthmeasure(ifclengthmeasure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcdampertypeenum +class ifcdampertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclayersetdirectionenum +class ifclayersetdirectionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpipefittingtypeenum +class ifcpipefittingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccurvestylefontselect +ifccurvestylefontselect = SELECT( + 'ifcpredefinedcurvefont', + 'ifccurvestylefont', + scope = schema_scope) +# Defined datatype ifcstairtypeenum +class ifcstairtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +ifccomplexnumber = ARRAY(1,2,'REAL', scope = schema_scope) +ifccompoundplaneanglemeasure = LIST(3,4,'INTEGER', scope = schema_scope) +# Defined datatype ifcevaporatortypeenum +class ifcevaporatortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmembertypeenum +class ifcmembertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcflowmetertypeenum +class ifcflowmetertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcprojectedortruelengthenum +class ifcprojectedortruelengthenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpositiveratiomeasure +class ifcpositiveratiomeasure(ifcratiomeasure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcobjectiveenum +class ifcobjectiveenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcconditioncriterionselect +ifcconditioncriterionselect = SELECT( + 'ifclabel', + 'ifcmeasurewithunit', + scope = schema_scope) +# Defined datatype ifcrotationalfrequencymeasure +class ifcrotationalfrequencymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvolumetricflowratemeasure +class ifcvolumetricflowratemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowstyleoperationenum +class ifcwindowstyleoperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcworkcontroltypeenum +class ifcworkcontroltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclinearmomentmeasure +class ifclinearmomentmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcphmeasure +class ifcphmeasure(REAL): + def __init__(self,*kargs): + pass + self.wr21() + + def wr21(self): + eval_wr21_wr = ((0 <= self) and (self <= 14)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + +# Defined datatype ifccondensertypeenum +class ifccondensertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmotorconnectiontypeenum +class ifcmotorconnectiontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsymbolstyleselect +ifcsymbolstyleselect = SELECT( + 'ifccolour', + scope = schema_scope) +# SELECT TYPE ifcfillareastyletileshapeselect +ifcfillareastyletileshapeselect = SELECT( + 'ifcfillareastyletilesymbolwithstyle', + scope = schema_scope) +# Defined datatype ifcmodulusofsubgradereactionmeasure +class ifcmodulusofsubgradereactionmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsolidanglemeasure +class ifcsolidanglemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwalltypeenum +class ifcwalltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcdocumentselect +ifcdocumentselect = SELECT( + 'ifcdocumentreference', + 'ifcdocumentinformation', + scope = schema_scope) +# Defined datatype ifcdoorstyleoperationenum +class ifcdoorstyleoperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcductsegmenttypeenum +class ifcductsegmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcionconcentrationmeasure +class ifcionconcentrationmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcnumericmeasure +class ifcnumericmeasure(NUMBER): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmassflowratemeasure +class ifcmassflowratemeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsurfacestyleelementselect +ifcsurfacestyleelementselect = SELECT( + 'ifcsurfacestyleshading', + 'ifcsurfacestylelighting', + 'ifcsurfacestylewithtextures', + 'ifcexternallydefinedsurfacestyle', + 'ifcsurfacestylerefraction', + scope = schema_scope) +# Defined datatype ifcoutlettypeenum +class ifcoutlettypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctemperaturegradientmeasure +class ifctemperaturegradientmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctextdecoration +class ifctextdecoration(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['none','underline','overline','line-through','blink']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifctimestamp +class ifctimestamp(INTEGER): + def __init__(self,*kargs): + pass + +# Defined datatype ifccablesegmenttypeenum +class ifccablesegmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcservicelifetypeenum +class ifcservicelifetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcarithmeticoperatorenum +class ifcarithmeticoperatorenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricresistancemeasure +class ifcelectricresistancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcilluminancemeasure +class ifcilluminancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrampflighttypeenum +class ifcrampflighttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcbsplinecurveform +class ifcbsplinecurveform(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectrictimecontroltypeenum +class ifcelectrictimecontroltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + + +#################### + # ENTITY ifcroot # +#################### +class ifcroot(BaseEntityClass): + '''Entity ifcroot definition. + + :param globalid + :type globalid:ifcgloballyuniqueid + + :param ownerhistory + :type ownerhistory:ifcownerhistory + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + ''' + def __init__( self , globalid,ownerhistory,name,description, ): + self.globalid = globalid + self.ownerhistory = ownerhistory + self.name = name + self.description = description + + @apply + def globalid(): + def fget( self ): + return self._globalid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument globalid is mantatory and can not be set to None') + if not check_type(value,ifcgloballyuniqueid): + self._globalid = ifcgloballyuniqueid(value) + else: + self._globalid = value + return property(**locals()) + + @apply + def ownerhistory(): + def fget( self ): + return self._ownerhistory + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ownerhistory is mantatory and can not be set to None') + if not check_type(value,ifcownerhistory): + self._ownerhistory = ifcownerhistory(value) + else: + self._ownerhistory = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY ifcrelationship # +#################### +class ifcrelationship(ifcroot): + '''Entity ifcrelationship definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcroot.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + +#################### + # ENTITY ifcrelconnects # +#################### +class ifcrelconnects(ifcrelationship): + '''Entity ifcrelconnects definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + +#################### + # ENTITY ifcrelinteractionrequirements # +#################### +class ifcrelinteractionrequirements(ifcrelconnects): + '''Entity ifcrelinteractionrequirements definition. + + :param dailyinteraction + :type dailyinteraction:ifccountmeasure + + :param importancerating + :type importancerating:ifcnormalisedratiomeasure + + :param locationofinteraction + :type locationofinteraction:ifcspatialstructureelement + + :param relatedspaceprogram + :type relatedspaceprogram:ifcspaceprogram + + :param relatingspaceprogram + :type relatingspaceprogram:ifcspaceprogram + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , dailyinteraction,importancerating,locationofinteraction,relatedspaceprogram,relatingspaceprogram, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.dailyinteraction = dailyinteraction + self.importancerating = importancerating + self.locationofinteraction = locationofinteraction + self.relatedspaceprogram = relatedspaceprogram + self.relatingspaceprogram = relatingspaceprogram + + @apply + def dailyinteraction(): + def fget( self ): + return self._dailyinteraction + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccountmeasure): + self._dailyinteraction = ifccountmeasure(value) + else: + self._dailyinteraction = value + else: + self._dailyinteraction = value + return property(**locals()) + + @apply + def importancerating(): + def fget( self ): + return self._importancerating + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._importancerating = ifcnormalisedratiomeasure(value) + else: + self._importancerating = value + else: + self._importancerating = value + return property(**locals()) + + @apply + def locationofinteraction(): + def fget( self ): + return self._locationofinteraction + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcspatialstructureelement): + self._locationofinteraction = ifcspatialstructureelement(value) + else: + self._locationofinteraction = value + else: + self._locationofinteraction = value + return property(**locals()) + + @apply + def relatedspaceprogram(): + def fget( self ): + return self._relatedspaceprogram + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedspaceprogram is mantatory and can not be set to None') + if not check_type(value,ifcspaceprogram): + self._relatedspaceprogram = ifcspaceprogram(value) + else: + self._relatedspaceprogram = value + return property(**locals()) + + @apply + def relatingspaceprogram(): + def fget( self ): + return self._relatingspaceprogram + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingspaceprogram is mantatory and can not be set to None') + if not check_type(value,ifcspaceprogram): + self._relatingspaceprogram = ifcspaceprogram(value) + else: + self._relatingspaceprogram = value + return property(**locals()) + +#################### + # ENTITY ifcobjectdefinition # +#################### +class ifcobjectdefinition(ifcroot): + '''Entity ifcobjectdefinition definition. + + :param hasassignments + :type hasassignments:SET(0,None,'ifcrelassigns', scope = schema_scope) + + :param isdecomposedby + :type isdecomposedby:SET(0,None,'ifcreldecomposes', scope = schema_scope) + + :param decomposes + :type decomposes:SET(0,1,'ifcreldecomposes', scope = schema_scope) + + :param hasassociations + :type hasassociations:SET(0,None,'ifcrelassociates', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcroot.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + + @apply + def hasassignments(): + def fget( self ): + return self._hasassignments + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasassignments is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isdecomposedby(): + def fget( self ): + return self._isdecomposedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isdecomposedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def decomposes(): + def fget( self ): + return self._decomposes + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument decomposes is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasassociations(): + def fget( self ): + return self._hasassociations + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasassociations is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcobject # +#################### +class ifcobject(ifcobjectdefinition): + '''Entity ifcobject definition. + + :param objecttype + :type objecttype:ifclabel + + :param isdefinedby + :type isdefinedby:SET(0,None,'ifcreldefines', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , objecttype, ): + ifcobjectdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.objecttype = objecttype + + @apply + def objecttype(): + def fget( self ): + return self._objecttype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._objecttype = ifclabel(value) + else: + self._objecttype = value + else: + self._objecttype = value + return property(**locals()) + + @apply + def isdefinedby(): + def fget( self ): + return self._isdefinedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isdefinedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcproduct # +#################### +class ifcproduct(ifcobject): + '''Entity ifcproduct definition. + + :param objectplacement + :type objectplacement:ifcobjectplacement + + :param representation + :type representation:ifcproductrepresentation + + :param referencedby + :type referencedby:SET(0,None,'ifcrelassignstoproduct', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , objectplacement,representation, ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.objectplacement = objectplacement + self.representation = representation + + @apply + def objectplacement(): + def fget( self ): + return self._objectplacement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcobjectplacement): + self._objectplacement = ifcobjectplacement(value) + else: + self._objectplacement = value + else: + self._objectplacement = value + return property(**locals()) + + @apply + def representation(): + def fget( self ): + return self._representation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcproductrepresentation): + self._representation = ifcproductrepresentation(value) + else: + self._representation = value + else: + self._representation = value + return property(**locals()) + + @apply + def referencedby(): + def fget( self ): + return self._referencedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referencedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (((EXISTS(self.representation) and EXISTS(self.objectplacement)) or (EXISTS(self.representation) and ( not ('IFC2X3.IFCPRODUCTDEFINITIONSHAPE' == TYPEOF(self.representation))))) or ( not EXISTS(self.representation))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcelement # +#################### +class ifcelement(ifcproduct): + '''Entity ifcelement definition. + + :param tag + :type tag:ifcidentifier + + :param hasstructuralmember + :type hasstructuralmember:SET(0,None,'ifcrelconnectsstructuralelement', scope = schema_scope) + + :param fillsvoids + :type fillsvoids:SET(0,1,'ifcrelfillselement', scope = schema_scope) + + :param connectedto + :type connectedto:SET(0,None,'ifcrelconnectselements', scope = schema_scope) + + :param hascoverings + :type hascoverings:SET(0,None,'ifcrelcoversbldgelements', scope = schema_scope) + + :param hasprojections + :type hasprojections:SET(0,None,'ifcrelprojectselement', scope = schema_scope) + + :param referencedinstructures + :type referencedinstructures:SET(0,None,'ifcrelreferencedinspatialstructure', scope = schema_scope) + + :param hasports + :type hasports:SET(0,None,'ifcrelconnectsporttoelement', scope = schema_scope) + + :param hasopenings + :type hasopenings:SET(0,None,'ifcrelvoidselement', scope = schema_scope) + + :param isconnectionrealization + :type isconnectionrealization:SET(0,None,'ifcrelconnectswithrealizingelements', scope = schema_scope) + + :param providesboundaries + :type providesboundaries:SET(0,None,'ifcrelspaceboundary', scope = schema_scope) + + :param connectedfrom + :type connectedfrom:SET(0,None,'ifcrelconnectselements', scope = schema_scope) + + :param containedinstructure + :type containedinstructure:SET(0,1,'ifcrelcontainedinspatialstructure', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , tag, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.tag = tag + + @apply + def tag(): + def fget( self ): + return self._tag + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._tag = ifcidentifier(value) + else: + self._tag = value + else: + self._tag = value + return property(**locals()) + + @apply + def hasstructuralmember(): + def fget( self ): + return self._hasstructuralmember + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasstructuralmember is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def fillsvoids(): + def fget( self ): + return self._fillsvoids + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument fillsvoids is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def connectedto(): + def fget( self ): + return self._connectedto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hascoverings(): + def fget( self ): + return self._hascoverings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hascoverings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasprojections(): + def fget( self ): + return self._hasprojections + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasprojections is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def referencedinstructures(): + def fget( self ): + return self._referencedinstructures + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referencedinstructures is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasports(): + def fget( self ): + return self._hasports + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasports is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasopenings(): + def fget( self ): + return self._hasopenings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasopenings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isconnectionrealization(): + def fget( self ): + return self._isconnectionrealization + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isconnectionrealization is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def providesboundaries(): + def fget( self ): + return self._providesboundaries + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument providesboundaries is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def connectedfrom(): + def fget( self ): + return self._connectedfrom + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedfrom is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def containedinstructure(): + def fget( self ): + return self._containedinstructure + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containedinstructure is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcvirtualelement # +#################### +class ifcvirtualelement(ifcelement): + '''Entity ifcvirtualelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifccurvestylefontpattern # +#################### +class ifccurvestylefontpattern(BaseEntityClass): + '''Entity ifccurvestylefontpattern definition. + + :param visiblesegmentlength + :type visiblesegmentlength:ifclengthmeasure + + :param invisiblesegmentlength + :type invisiblesegmentlength:ifcpositivelengthmeasure + ''' + def __init__( self , visiblesegmentlength,invisiblesegmentlength, ): + self.visiblesegmentlength = visiblesegmentlength + self.invisiblesegmentlength = invisiblesegmentlength + + @apply + def visiblesegmentlength(): + def fget( self ): + return self._visiblesegmentlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument visiblesegmentlength is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._visiblesegmentlength = ifclengthmeasure(value) + else: + self._visiblesegmentlength = value + return property(**locals()) + + @apply + def invisiblesegmentlength(): + def fget( self ): + return self._invisiblesegmentlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument invisiblesegmentlength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._invisiblesegmentlength = ifcpositivelengthmeasure(value) + else: + self._invisiblesegmentlength = value + return property(**locals()) + def wr01(self): + eval_wr01_wr = (self.visiblesegmentlength >= 0) + if not eval_wr01_wr: + raise AssertionError('Rule wr01 violated') + else: + return eval_wr01_wr + + +#################### + # ENTITY ifcrelconnectsstructuralactivity # +#################### +class ifcrelconnectsstructuralactivity(ifcrelconnects): + '''Entity ifcrelconnectsstructuralactivity definition. + + :param relatingelement + :type relatingelement:ifcstructuralactivityassignmentselect + + :param relatedstructuralactivity + :type relatedstructuralactivity:ifcstructuralactivity + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingelement,relatedstructuralactivity, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingelement = relatingelement + self.relatedstructuralactivity = relatedstructuralactivity + + @apply + def relatingelement(): + def fget( self ): + return self._relatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingelement is mantatory and can not be set to None') + if not check_type(value,ifcstructuralactivityassignmentselect): + self._relatingelement = ifcstructuralactivityassignmentselect(value) + else: + self._relatingelement = value + return property(**locals()) + + @apply + def relatedstructuralactivity(): + def fget( self ): + return self._relatedstructuralactivity + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedstructuralactivity is mantatory and can not be set to None') + if not check_type(value,ifcstructuralactivity): + self._relatedstructuralactivity = ifcstructuralactivity(value) + else: + self._relatedstructuralactivity = value + return property(**locals()) + +#################### + # ENTITY ifcmaterialproperties # +#################### +class ifcmaterialproperties(BaseEntityClass): + '''Entity ifcmaterialproperties definition. + + :param material + :type material:ifcmaterial + ''' + def __init__( self , material, ): + self.material = material + + @apply + def material(): + def fget( self ): + return self._material + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument material is mantatory and can not be set to None') + if not check_type(value,ifcmaterial): + self._material = ifcmaterial(value) + else: + self._material = value + return property(**locals()) + +#################### + # ENTITY ifchygroscopicmaterialproperties # +#################### +class ifchygroscopicmaterialproperties(ifcmaterialproperties): + '''Entity ifchygroscopicmaterialproperties definition. + + :param uppervaporresistancefactor + :type uppervaporresistancefactor:ifcpositiveratiomeasure + + :param lowervaporresistancefactor + :type lowervaporresistancefactor:ifcpositiveratiomeasure + + :param isothermalmoisturecapacity + :type isothermalmoisturecapacity:ifcisothermalmoisturecapacitymeasure + + :param vaporpermeability + :type vaporpermeability:ifcvaporpermeabilitymeasure + + :param moisturediffusivity + :type moisturediffusivity:ifcmoisturediffusivitymeasure + ''' + def __init__( self , inherited0__material , uppervaporresistancefactor,lowervaporresistancefactor,isothermalmoisturecapacity,vaporpermeability,moisturediffusivity, ): + ifcmaterialproperties.__init__(self , inherited0__material , ) + self.uppervaporresistancefactor = uppervaporresistancefactor + self.lowervaporresistancefactor = lowervaporresistancefactor + self.isothermalmoisturecapacity = isothermalmoisturecapacity + self.vaporpermeability = vaporpermeability + self.moisturediffusivity = moisturediffusivity + + @apply + def uppervaporresistancefactor(): + def fget( self ): + return self._uppervaporresistancefactor + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._uppervaporresistancefactor = ifcpositiveratiomeasure(value) + else: + self._uppervaporresistancefactor = value + else: + self._uppervaporresistancefactor = value + return property(**locals()) + + @apply + def lowervaporresistancefactor(): + def fget( self ): + return self._lowervaporresistancefactor + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._lowervaporresistancefactor = ifcpositiveratiomeasure(value) + else: + self._lowervaporresistancefactor = value + else: + self._lowervaporresistancefactor = value + return property(**locals()) + + @apply + def isothermalmoisturecapacity(): + def fget( self ): + return self._isothermalmoisturecapacity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcisothermalmoisturecapacitymeasure): + self._isothermalmoisturecapacity = ifcisothermalmoisturecapacitymeasure(value) + else: + self._isothermalmoisturecapacity = value + else: + self._isothermalmoisturecapacity = value + return property(**locals()) + + @apply + def vaporpermeability(): + def fget( self ): + return self._vaporpermeability + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvaporpermeabilitymeasure): + self._vaporpermeability = ifcvaporpermeabilitymeasure(value) + else: + self._vaporpermeability = value + else: + self._vaporpermeability = value + return property(**locals()) + + @apply + def moisturediffusivity(): + def fget( self ): + return self._moisturediffusivity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmoisturediffusivitymeasure): + self._moisturediffusivity = ifcmoisturediffusivitymeasure(value) + else: + self._moisturediffusivity = value + else: + self._moisturediffusivity = value + return property(**locals()) + +#################### + # ENTITY ifcrelassigns # +#################### +class ifcrelassigns(ifcrelationship): + '''Entity ifcrelassigns definition. + + :param relatedobjects + :type relatedobjects:SET(1,None,'ifcobjectdefinition', scope = schema_scope) + + :param relatedobjectstype + :type relatedobjectstype:ifcobjecttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedobjects,relatedobjectstype, ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedobjects = relatedobjects + self.relatedobjectstype = relatedobjectstype + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcobjectdefinition', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + + @apply + def relatedobjectstype(): + def fget( self ): + return self._relatedobjectstype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcobjecttypeenum): + self._relatedobjectstype = ifcobjecttypeenum(value) + else: + self._relatedobjectstype = value + else: + self._relatedobjectstype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ifccorrectobjectassignment(self.relatedobjectstype,self.relatedobjects) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelassignstocontrol # +#################### +class ifcrelassignstocontrol(ifcrelassigns): + '''Entity ifcrelassignstocontrol definition. + + :param relatingcontrol + :type relatingcontrol:ifccontrol + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingcontrol, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingcontrol = relatingcontrol + + @apply + def relatingcontrol(): + def fget( self ): + return self._relatingcontrol + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingcontrol is mantatory and can not be set to None') + if not check_type(value,ifccontrol): + self._relatingcontrol = ifccontrol(value) + else: + self._relatingcontrol = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelschedulescostitems # +#################### +class ifcrelschedulescostitems(ifcrelassignstocontrol): + '''Entity ifcrelschedulescostitems definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatingcontrol , ): + ifcrelassignstocontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatingcontrol , ) + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = ('IFC2X3.IFCCOSTSCHEDULE' == TYPEOF(self.self.ifcrelassignstocontrol.self.relatingcontrol)) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + +#################### + # ENTITY ifcproperty # +#################### +class ifcproperty(BaseEntityClass): + '''Entity ifcproperty definition. + + :param name + :type name:ifcidentifier + + :param description + :type description:ifctext + + :param propertyfordependance + :type propertyfordependance:SET(0,None,'ifcpropertydependencyrelationship', scope = schema_scope) + + :param propertydependson + :type propertydependson:SET(0,None,'ifcpropertydependencyrelationship', scope = schema_scope) + + :param partofcomplex + :type partofcomplex:SET(0,1,'ifccomplexproperty', scope = schema_scope) + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._name = ifcidentifier(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def propertyfordependance(): + def fget( self ): + return self._propertyfordependance + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument propertyfordependance is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def propertydependson(): + def fget( self ): + return self._propertydependson + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument propertydependson is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def partofcomplex(): + def fget( self ): + return self._partofcomplex + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofcomplex is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsimpleproperty # +#################### +class ifcsimpleproperty(ifcproperty): + '''Entity ifcsimpleproperty definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + ifcproperty.__init__(self , inherited0__name , inherited1__description , ) + +#################### + # ENTITY ifcpropertyenumeratedvalue # +#################### +class ifcpropertyenumeratedvalue(ifcsimpleproperty): + '''Entity ifcpropertyenumeratedvalue definition. + + :param enumerationvalues + :type enumerationvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param enumerationreference + :type enumerationreference:ifcpropertyenumeration + ''' + def __init__( self , inherited0__name , inherited1__description , enumerationvalues,enumerationreference, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.enumerationvalues = enumerationvalues + self.enumerationreference = enumerationreference + + @apply + def enumerationvalues(): + def fget( self ): + return self._enumerationvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument enumerationvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._enumerationvalues = LIST(value) + else: + self._enumerationvalues = value + return property(**locals()) + + @apply + def enumerationreference(): + def fget( self ): + return self._enumerationreference + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpropertyenumeration): + self._enumerationreference = ifcpropertyenumeration(value) + else: + self._enumerationreference = value + else: + self._enumerationreference = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not EXISTS(self.enumerationreference)) or (SIZEOF(None) == SIZEOF(self.enumerationvalues))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcreinforcementbarproperties # +#################### +class ifcreinforcementbarproperties(BaseEntityClass): + '''Entity ifcreinforcementbarproperties definition. + + :param totalcrosssectionarea + :type totalcrosssectionarea:ifcareameasure + + :param steelgrade + :type steelgrade:ifclabel + + :param barsurface + :type barsurface:ifcreinforcingbarsurfaceenum + + :param effectivedepth + :type effectivedepth:ifclengthmeasure + + :param nominalbardiameter + :type nominalbardiameter:ifcpositivelengthmeasure + + :param barcount + :type barcount:ifccountmeasure + ''' + def __init__( self , totalcrosssectionarea,steelgrade,barsurface,effectivedepth,nominalbardiameter,barcount, ): + self.totalcrosssectionarea = totalcrosssectionarea + self.steelgrade = steelgrade + self.barsurface = barsurface + self.effectivedepth = effectivedepth + self.nominalbardiameter = nominalbardiameter + self.barcount = barcount + + @apply + def totalcrosssectionarea(): + def fget( self ): + return self._totalcrosssectionarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument totalcrosssectionarea is mantatory and can not be set to None') + if not check_type(value,ifcareameasure): + self._totalcrosssectionarea = ifcareameasure(value) + else: + self._totalcrosssectionarea = value + return property(**locals()) + + @apply + def steelgrade(): + def fget( self ): + return self._steelgrade + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument steelgrade is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._steelgrade = ifclabel(value) + else: + self._steelgrade = value + return property(**locals()) + + @apply + def barsurface(): + def fget( self ): + return self._barsurface + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreinforcingbarsurfaceenum): + self._barsurface = ifcreinforcingbarsurfaceenum(value) + else: + self._barsurface = value + else: + self._barsurface = value + return property(**locals()) + + @apply + def effectivedepth(): + def fget( self ): + return self._effectivedepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._effectivedepth = ifclengthmeasure(value) + else: + self._effectivedepth = value + else: + self._effectivedepth = value + return property(**locals()) + + @apply + def nominalbardiameter(): + def fget( self ): + return self._nominalbardiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominalbardiameter = ifcpositivelengthmeasure(value) + else: + self._nominalbardiameter = value + else: + self._nominalbardiameter = value + return property(**locals()) + + @apply + def barcount(): + def fget( self ): + return self._barcount + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccountmeasure): + self._barcount = ifccountmeasure(value) + else: + self._barcount = value + else: + self._barcount = value + return property(**locals()) + +#################### + # ENTITY ifcrepresentationitem # +#################### +class ifcrepresentationitem(BaseEntityClass): + '''Entity ifcrepresentationitem definition. + + :param layerassignments + :type layerassignments:SET(0,None,'ifcpresentationlayerassignment', scope = schema_scope) + + :param styledbyitem + :type styledbyitem:SET(0,1,'ifcstyleditem', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def layerassignments(): + def fget( self ): + return self._layerassignments + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument layerassignments is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def styledbyitem(): + def fget( self ): + return self._styledbyitem + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument styledbyitem is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcgeometricrepresentationitem # +#################### +class ifcgeometricrepresentationitem(ifcrepresentationitem): + '''Entity ifcgeometricrepresentationitem definition. + ''' + def __init__( self , ): + ifcrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifcsurface # +#################### +class ifcsurface(ifcgeometricrepresentationitem): + '''Entity ifcsurface definition. + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifcsweptsurface # +#################### +class ifcsweptsurface(ifcsurface): + '''Entity ifcsweptsurface definition. + + :param sweptcurve + :type sweptcurve:ifcprofiledef + + :param position + :type position:ifcaxis2placement3d + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , sweptcurve,position, ): + ifcsurface.__init__(self , ) + self.sweptcurve = sweptcurve + self.position = position + + @apply + def sweptcurve(): + def fget( self ): + return self._sweptcurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sweptcurve is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._sweptcurve = ifcprofiledef(value) + else: + self._sweptcurve = value + return property(**locals()) + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.position.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('IFC2X3.IFCDERIVEDPROFILEDEF' == TYPEOF(self.sweptcurve))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.sweptcurve.self.profiletype == ifcprofiletypeenum.self.curve) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcsurfaceofrevolution # +#################### +class ifcsurfaceofrevolution(ifcsweptsurface): + '''Entity ifcsurfaceofrevolution definition. + + :param axisposition + :type axisposition:ifcaxis1placement + + :param axisline + :type axisline:ifcline + ''' + def __init__( self , inherited0__sweptcurve , inherited1__position , axisposition, ): + ifcsweptsurface.__init__(self , inherited0__sweptcurve , inherited1__position , ) + self.axisposition = axisposition + + @apply + def axisposition(): + def fget( self ): + return self._axisposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axisposition is mantatory and can not be set to None') + if not check_type(value,ifcaxis1placement): + self._axisposition = ifcaxis1placement(value) + else: + self._axisposition = value + return property(**locals()) + + @apply + def axisline(): + def fget( self ): + attribute_eval = (((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifccurve()) == ifcline(self.axisposition.self.location,(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(self.axisposition.self.z,1))) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument axisline is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcprofiledef # +#################### +class ifcprofiledef(BaseEntityClass): + '''Entity ifcprofiledef definition. + + :param profiletype + :type profiletype:ifcprofiletypeenum + + :param profilename + :type profilename:ifclabel + ''' + def __init__( self , profiletype,profilename, ): + self.profiletype = profiletype + self.profilename = profilename + + @apply + def profiletype(): + def fget( self ): + return self._profiletype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument profiletype is mantatory and can not be set to None') + if not check_type(value,ifcprofiletypeenum): + self._profiletype = ifcprofiletypeenum(value) + else: + self._profiletype = value + return property(**locals()) + + @apply + def profilename(): + def fget( self ): + return self._profilename + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._profilename = ifclabel(value) + else: + self._profilename = value + else: + self._profilename = value + return property(**locals()) + +#################### + # ENTITY ifcparameterizedprofiledef # +#################### +class ifcparameterizedprofiledef(ifcprofiledef): + '''Entity ifcparameterizedprofiledef definition. + + :param position + :type position:ifcaxis2placement2d + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , position, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement2d): + self._position = ifcaxis2placement2d(value) + else: + self._position = value + return property(**locals()) + +#################### + # ENTITY ifccranerailashapeprofiledef # +#################### +class ifccranerailashapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifccranerailashapeprofiledef definition. + + :param overallheight + :type overallheight:ifcpositivelengthmeasure + + :param basewidth2 + :type basewidth2:ifcpositivelengthmeasure + + :param radius + :type radius:ifcpositivelengthmeasure + + :param headwidth + :type headwidth:ifcpositivelengthmeasure + + :param headdepth2 + :type headdepth2:ifcpositivelengthmeasure + + :param headdepth3 + :type headdepth3:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param basewidth4 + :type basewidth4:ifcpositivelengthmeasure + + :param basedepth1 + :type basedepth1:ifcpositivelengthmeasure + + :param basedepth2 + :type basedepth2:ifcpositivelengthmeasure + + :param basedepth3 + :type basedepth3:ifcpositivelengthmeasure + + :param centreofgravityiny + :type centreofgravityiny:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , overallheight,basewidth2,radius,headwidth,headdepth2,headdepth3,webthickness,basewidth4,basedepth1,basedepth2,basedepth3,centreofgravityiny, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.overallheight = overallheight + self.basewidth2 = basewidth2 + self.radius = radius + self.headwidth = headwidth + self.headdepth2 = headdepth2 + self.headdepth3 = headdepth3 + self.webthickness = webthickness + self.basewidth4 = basewidth4 + self.basedepth1 = basedepth1 + self.basedepth2 = basedepth2 + self.basedepth3 = basedepth3 + self.centreofgravityiny = centreofgravityiny + + @apply + def overallheight(): + def fget( self ): + return self._overallheight + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument overallheight is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._overallheight = ifcpositivelengthmeasure(value) + else: + self._overallheight = value + return property(**locals()) + + @apply + def basewidth2(): + def fget( self ): + return self._basewidth2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basewidth2 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._basewidth2 = ifcpositivelengthmeasure(value) + else: + self._basewidth2 = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + else: + self._radius = value + return property(**locals()) + + @apply + def headwidth(): + def fget( self ): + return self._headwidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument headwidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._headwidth = ifcpositivelengthmeasure(value) + else: + self._headwidth = value + return property(**locals()) + + @apply + def headdepth2(): + def fget( self ): + return self._headdepth2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument headdepth2 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._headdepth2 = ifcpositivelengthmeasure(value) + else: + self._headdepth2 = value + return property(**locals()) + + @apply + def headdepth3(): + def fget( self ): + return self._headdepth3 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument headdepth3 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._headdepth3 = ifcpositivelengthmeasure(value) + else: + self._headdepth3 = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def basewidth4(): + def fget( self ): + return self._basewidth4 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basewidth4 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._basewidth4 = ifcpositivelengthmeasure(value) + else: + self._basewidth4 = value + return property(**locals()) + + @apply + def basedepth1(): + def fget( self ): + return self._basedepth1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basedepth1 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._basedepth1 = ifcpositivelengthmeasure(value) + else: + self._basedepth1 = value + return property(**locals()) + + @apply + def basedepth2(): + def fget( self ): + return self._basedepth2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basedepth2 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._basedepth2 = ifcpositivelengthmeasure(value) + else: + self._basedepth2 = value + return property(**locals()) + + @apply + def basedepth3(): + def fget( self ): + return self._basedepth3 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basedepth3 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._basedepth3 = ifcpositivelengthmeasure(value) + else: + self._basedepth3 = value + return property(**locals()) + + @apply + def centreofgravityiny(): + def fget( self ): + return self._centreofgravityiny + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._centreofgravityiny = ifcpositivelengthmeasure(value) + else: + self._centreofgravityiny = value + else: + self._centreofgravityiny = value + return property(**locals()) + +#################### + # ENTITY ifctypeobject # +#################### +class ifctypeobject(ifcobjectdefinition): + '''Entity ifctypeobject definition. + + :param applicableoccurrence + :type applicableoccurrence:ifclabel + + :param haspropertysets + :type haspropertysets:SET(1,None,'ifcpropertysetdefinition', scope = schema_scope) + + :param objecttypeof + :type objecttypeof:SET(0,1,'ifcreldefinesbytype', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , applicableoccurrence,haspropertysets, ): + ifcobjectdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.applicableoccurrence = applicableoccurrence + self.haspropertysets = haspropertysets + + @apply + def applicableoccurrence(): + def fget( self ): + return self._applicableoccurrence + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._applicableoccurrence = ifclabel(value) + else: + self._applicableoccurrence = value + else: + self._applicableoccurrence = value + return property(**locals()) + + @apply + def haspropertysets(): + def fget( self ): + return self._haspropertysets + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcpropertysetdefinition', scope = schema_scope)): + self._haspropertysets = SET(value) + else: + self._haspropertysets = value + else: + self._haspropertysets = value + return property(**locals()) + + @apply + def objecttypeof(): + def fget( self ): + return self._objecttypeof + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument objecttypeof is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifctypeproduct # +#################### +class ifctypeproduct(ifctypeobject): + '''Entity ifctypeproduct definition. + + :param representationmaps + :type representationmaps:LIST(1,None,'ifcrepresentationmap', scope = schema_scope) + + :param tag + :type tag:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , representationmaps,tag, ): + ifctypeobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , ) + self.representationmaps = representationmaps + self.tag = tag + + @apply + def representationmaps(): + def fget( self ): + return self._representationmaps + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcrepresentationmap', scope = schema_scope)): + self._representationmaps = LIST(value) + else: + self._representationmaps = value + else: + self._representationmaps = value + return property(**locals()) + + @apply + def tag(): + def fget( self ): + return self._tag + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._tag = ifclabel(value) + else: + self._tag = value + else: + self._tag = value + return property(**locals()) + def wr41(self): + eval_wr41_wr = (( not EXISTS(self.self.ifctypeobject.self.objecttypeof[1])) or (SIZEOF(None) == 0)) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + +#################### + # ENTITY ifcelementtype # +#################### +class ifcelementtype(ifctypeproduct): + '''Entity ifcelementtype definition. + + :param elementtype + :type elementtype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , elementtype, ): + ifctypeproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , ) + self.elementtype = elementtype + + @apply + def elementtype(): + def fget( self ): + return self._elementtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._elementtype = ifclabel(value) + else: + self._elementtype = value + else: + self._elementtype = value + return property(**locals()) + +#################### + # ENTITY ifcdistributionelementtype # +#################### +class ifcdistributionelementtype(ifcelementtype): + '''Entity ifcdistributionelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcdistributionflowelementtype # +#################### +class ifcdistributionflowelementtype(ifcdistributionelementtype): + '''Entity ifcdistributionflowelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcflowsegmenttype # +#################### +class ifcflowsegmenttype(ifcdistributionflowelementtype): + '''Entity ifcflowsegmenttype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifccablesegmenttype # +#################### +class ifccablesegmenttype(ifcflowsegmenttype): + '''Entity ifccablesegmenttype definition. + + :param predefinedtype + :type predefinedtype:ifccablesegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowsegmenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccablesegmenttypeenum): + self._predefinedtype = ifccablesegmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcpropertydefinition # +#################### +class ifcpropertydefinition(ifcroot): + '''Entity ifcpropertydefinition definition. + + :param hasassociations + :type hasassociations:SET(0,None,'ifcrelassociates', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcroot.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + + @apply + def hasassociations(): + def fget( self ): + return self._hasassociations + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasassociations is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcpropertysetdefinition # +#################### +class ifcpropertysetdefinition(ifcpropertydefinition): + '''Entity ifcpropertysetdefinition definition. + + :param propertydefinitionof + :type propertydefinitionof:SET(0,1,'ifcreldefinesbyproperties', scope = schema_scope) + + :param definestype + :type definestype:SET(0,1,'ifctypeobject', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcpropertydefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + + @apply + def propertydefinitionof(): + def fget( self ): + return self._propertydefinitionof + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument propertydefinitionof is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def definestype(): + def fget( self ): + return self._definestype + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument definestype is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcelementquantity # +#################### +class ifcelementquantity(ifcpropertysetdefinition): + '''Entity ifcelementquantity definition. + + :param methodofmeasurement + :type methodofmeasurement:ifclabel + + :param quantities + :type quantities:SET(1,None,'ifcphysicalquantity', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , methodofmeasurement,quantities, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.methodofmeasurement = methodofmeasurement + self.quantities = quantities + + @apply + def methodofmeasurement(): + def fget( self ): + return self._methodofmeasurement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._methodofmeasurement = ifclabel(value) + else: + self._methodofmeasurement = value + else: + self._methodofmeasurement = value + return property(**locals()) + + @apply + def quantities(): + def fget( self ): + return self._quantities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument quantities is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcphysicalquantity', scope = schema_scope)): + self._quantities = SET(value) + else: + self._quantities = value + return property(**locals()) + +#################### + # ENTITY ifcenergyconversiondevicetype # +#################### +class ifcenergyconversiondevicetype(ifcdistributionflowelementtype): + '''Entity ifcenergyconversiondevicetype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifchumidifiertype # +#################### +class ifchumidifiertype(ifcenergyconversiondevicetype): + '''Entity ifchumidifiertype definition. + + :param predefinedtype + :type predefinedtype:ifchumidifiertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifchumidifiertypeenum): + self._predefinedtype = ifchumidifiertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifchumidifiertypeenum.self.userdefined) or ((self.predefinedtype == ifchumidifiertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcstructuralitem # +#################### +class ifcstructuralitem(ifcproduct): + '''Entity ifcstructuralitem definition. + + :param assignedstructuralactivity + :type assignedstructuralactivity:SET(0,None,'ifcrelconnectsstructuralactivity', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + + @apply + def assignedstructuralactivity(): + def fget( self ): + return self._assignedstructuralactivity + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument assignedstructuralactivity is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructuralload # +#################### +class ifcstructuralload(BaseEntityClass): + '''Entity ifcstructuralload definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralloadstatic # +#################### +class ifcstructuralloadstatic(ifcstructuralload): + '''Entity ifcstructuralloadstatic definition. + ''' + def __init__( self , inherited0__name , ): + ifcstructuralload.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcstructuralloadsingledisplacement # +#################### +class ifcstructuralloadsingledisplacement(ifcstructuralloadstatic): + '''Entity ifcstructuralloadsingledisplacement definition. + + :param displacementx + :type displacementx:ifclengthmeasure + + :param displacementy + :type displacementy:ifclengthmeasure + + :param displacementz + :type displacementz:ifclengthmeasure + + :param rotationaldisplacementrx + :type rotationaldisplacementrx:ifcplaneanglemeasure + + :param rotationaldisplacementry + :type rotationaldisplacementry:ifcplaneanglemeasure + + :param rotationaldisplacementrz + :type rotationaldisplacementrz:ifcplaneanglemeasure + ''' + def __init__( self , inherited0__name , displacementx,displacementy,displacementz,rotationaldisplacementrx,rotationaldisplacementry,rotationaldisplacementrz, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.displacementx = displacementx + self.displacementy = displacementy + self.displacementz = displacementz + self.rotationaldisplacementrx = rotationaldisplacementrx + self.rotationaldisplacementry = rotationaldisplacementry + self.rotationaldisplacementrz = rotationaldisplacementrz + + @apply + def displacementx(): + def fget( self ): + return self._displacementx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._displacementx = ifclengthmeasure(value) + else: + self._displacementx = value + else: + self._displacementx = value + return property(**locals()) + + @apply + def displacementy(): + def fget( self ): + return self._displacementy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._displacementy = ifclengthmeasure(value) + else: + self._displacementy = value + else: + self._displacementy = value + return property(**locals()) + + @apply + def displacementz(): + def fget( self ): + return self._displacementz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._displacementz = ifclengthmeasure(value) + else: + self._displacementz = value + else: + self._displacementz = value + return property(**locals()) + + @apply + def rotationaldisplacementrx(): + def fget( self ): + return self._rotationaldisplacementrx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._rotationaldisplacementrx = ifcplaneanglemeasure(value) + else: + self._rotationaldisplacementrx = value + else: + self._rotationaldisplacementrx = value + return property(**locals()) + + @apply + def rotationaldisplacementry(): + def fget( self ): + return self._rotationaldisplacementry + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._rotationaldisplacementry = ifcplaneanglemeasure(value) + else: + self._rotationaldisplacementry = value + else: + self._rotationaldisplacementry = value + return property(**locals()) + + @apply + def rotationaldisplacementrz(): + def fget( self ): + return self._rotationaldisplacementrz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._rotationaldisplacementrz = ifcplaneanglemeasure(value) + else: + self._rotationaldisplacementrz = value + else: + self._rotationaldisplacementrz = value + return property(**locals()) + +#################### + # ENTITY ifctransportelementtype # +#################### +class ifctransportelementtype(ifcelementtype): + '''Entity ifctransportelementtype definition. + + :param predefinedtype + :type predefinedtype:ifctransportelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctransportelementtypeenum): + self._predefinedtype = ifctransportelementtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifctrapeziumprofiledef # +#################### +class ifctrapeziumprofiledef(ifcparameterizedprofiledef): + '''Entity ifctrapeziumprofiledef definition. + + :param bottomxdim + :type bottomxdim:ifcpositivelengthmeasure + + :param topxdim + :type topxdim:ifcpositivelengthmeasure + + :param ydim + :type ydim:ifcpositivelengthmeasure + + :param topxoffset + :type topxoffset:ifclengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , bottomxdim,topxdim,ydim,topxoffset, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.bottomxdim = bottomxdim + self.topxdim = topxdim + self.ydim = ydim + self.topxoffset = topxoffset + + @apply + def bottomxdim(): + def fget( self ): + return self._bottomxdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bottomxdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._bottomxdim = ifcpositivelengthmeasure(value) + else: + self._bottomxdim = value + return property(**locals()) + + @apply + def topxdim(): + def fget( self ): + return self._topxdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument topxdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._topxdim = ifcpositivelengthmeasure(value) + else: + self._topxdim = value + return property(**locals()) + + @apply + def ydim(): + def fget( self ): + return self._ydim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ydim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ydim = ifcpositivelengthmeasure(value) + else: + self._ydim = value + return property(**locals()) + + @apply + def topxoffset(): + def fget( self ): + return self._topxoffset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument topxoffset is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._topxoffset = ifclengthmeasure(value) + else: + self._topxoffset = value + return property(**locals()) + +#################### + # ENTITY ifczshapeprofiledef # +#################### +class ifczshapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifczshapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param flangewidth + :type flangewidth:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param flangethickness + :type flangethickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcpositivelengthmeasure + + :param edgeradius + :type edgeradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,flangewidth,webthickness,flangethickness,filletradius,edgeradius, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.flangewidth = flangewidth + self.webthickness = webthickness + self.flangethickness = flangethickness + self.filletradius = filletradius + self.edgeradius = edgeradius + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def flangewidth(): + def fget( self ): + return self._flangewidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangewidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangewidth = ifcpositivelengthmeasure(value) + else: + self._flangewidth = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def flangethickness(): + def fget( self ): + return self._flangethickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangethickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangethickness = ifcpositivelengthmeasure(value) + else: + self._flangethickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._filletradius = ifcpositivelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + + @apply + def edgeradius(): + def fget( self ): + return self._edgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._edgeradius = ifcpositivelengthmeasure(value) + else: + self._edgeradius = value + else: + self._edgeradius = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (self.flangethickness < (self.depth / 2)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcstyleditem # +#################### +class ifcstyleditem(ifcrepresentationitem): + '''Entity ifcstyleditem definition. + + :param item + :type item:ifcrepresentationitem + + :param styles + :type styles:SET(1,None,'ifcpresentationstyleassignment', scope = schema_scope) + + :param name + :type name:ifclabel + ''' + def __init__( self , item,styles,name, ): + ifcrepresentationitem.__init__(self , ) + self.item = item + self.styles = styles + self.name = name + + @apply + def item(): + def fget( self ): + return self._item + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrepresentationitem): + self._item = ifcrepresentationitem(value) + else: + self._item = value + else: + self._item = value + return property(**locals()) + + @apply + def styles(): + def fget( self ): + return self._styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcpresentationstyleassignment', scope = schema_scope)): + self._styles = SET(value) + else: + self._styles = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (SIZEOF(self.styles) == 1) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = ( not ('IFC2X3.IFCSTYLEDITEM' == TYPEOF(self.item))) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + +#################### + # ENTITY ifcannotationoccurrence # +#################### +class ifcannotationoccurrence(ifcstyleditem): + '''Entity ifcannotationoccurrence definition. + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , ): + ifcstyleditem.__init__(self , inherited0__item , inherited1__styles , inherited2__name , ) + +#################### + # ENTITY ifcannotationtextoccurrence # +#################### +class ifcannotationtextoccurrence(ifcannotationoccurrence): + '''Entity ifcannotationtextoccurrence definition. + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , ): + ifcannotationoccurrence.__init__(self , inherited0__item , inherited1__styles , inherited2__name , ) + def wr31(self): + eval_wr31_wr = (( not EXISTS(self.self.ifcstyleditem.self.item)) or ('IFC2X3.IFCTEXTLITERAL' == TYPEOF(self.self.ifcstyleditem.self.item))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifccontrol # +#################### +class ifccontrol(ifcobject): + '''Entity ifccontrol definition. + + :param controls + :type controls:SET(0,None,'ifcrelassignstocontrol', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + + @apply + def controls(): + def fget( self ): + return self._controls + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument controls is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifccostitem # +#################### +class ifccostitem(ifccontrol): + '''Entity ifccostitem definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + +#################### + # ENTITY ifclightsource # +#################### +class ifclightsource(ifcgeometricrepresentationitem): + '''Entity ifclightsource definition. + + :param name + :type name:ifclabel + + :param lightcolour + :type lightcolour:ifccolourrgb + + :param ambientintensity + :type ambientintensity:ifcnormalisedratiomeasure + + :param intensity + :type intensity:ifcnormalisedratiomeasure + ''' + def __init__( self , name,lightcolour,ambientintensity,intensity, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.name = name + self.lightcolour = lightcolour + self.ambientintensity = ambientintensity + self.intensity = intensity + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def lightcolour(): + def fget( self ): + return self._lightcolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lightcolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._lightcolour = ifccolourrgb(value) + else: + self._lightcolour = value + return property(**locals()) + + @apply + def ambientintensity(): + def fget( self ): + return self._ambientintensity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._ambientintensity = ifcnormalisedratiomeasure(value) + else: + self._ambientintensity = value + else: + self._ambientintensity = value + return property(**locals()) + + @apply + def intensity(): + def fget( self ): + return self._intensity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._intensity = ifcnormalisedratiomeasure(value) + else: + self._intensity = value + else: + self._intensity = value + return property(**locals()) + +#################### + # ENTITY ifcfeatureelement # +#################### +class ifcfeatureelement(ifcelement): + '''Entity ifcfeatureelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcfeatureelementaddition # +#################### +class ifcfeatureelementaddition(ifcfeatureelement): + '''Entity ifcfeatureelementaddition definition. + + :param projectselements + :type projectselements:ifcrelprojectselement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcfeatureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def projectselements(): + def fget( self ): + return self._projectselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument projectselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructuralconnectioncondition # +#################### +class ifcstructuralconnectioncondition(BaseEntityClass): + '''Entity ifcstructuralconnectioncondition definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcpoint # +#################### +class ifcpoint(ifcgeometricrepresentationitem): + '''Entity ifcpoint definition. + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifccartesianpoint # +#################### +class ifccartesianpoint(ifcpoint): + '''Entity ifccartesianpoint definition. + + :param coordinates + :type coordinates:LIST(1,3,'REAL', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , coordinates, ): + ifcpoint.__init__(self , ) + self.coordinates = coordinates + + @apply + def coordinates(): + def fget( self ): + return self._coordinates + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordinates is mantatory and can not be set to None') + if not check_type(value,LIST(1,3,'REAL', scope = schema_scope)): + self._coordinates = LIST(value) + else: + self._coordinates = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = HIINDEX(self.coordinates) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (HIINDEX(self.coordinates) >= 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcexternalreference # +#################### +class ifcexternalreference(BaseEntityClass): + '''Entity ifcexternalreference definition. + + :param location + :type location:ifclabel + + :param itemreference + :type itemreference:ifcidentifier + + :param name + :type name:ifclabel + ''' + def __init__( self , location,itemreference,name, ): + self.location = location + self.itemreference = itemreference + self.name = name + + @apply + def location(): + def fget( self ): + return self._location + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._location = ifclabel(value) + else: + self._location = value + else: + self._location = value + return property(**locals()) + + @apply + def itemreference(): + def fget( self ): + return self._itemreference + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._itemreference = ifcidentifier(value) + else: + self._itemreference = value + else: + self._itemreference = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((EXISTS(self.itemreference) or EXISTS(self.location)) or EXISTS(self.name)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcclassificationreference # +#################### +class ifcclassificationreference(ifcexternalreference): + '''Entity ifcclassificationreference definition. + + :param referencedsource + :type referencedsource:ifcclassification + ''' + def __init__( self , inherited0__location , inherited1__itemreference , inherited2__name , referencedsource, ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__itemreference , inherited2__name , ) + self.referencedsource = referencedsource + + @apply + def referencedsource(): + def fget( self ): + return self._referencedsource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcclassification): + self._referencedsource = ifcclassification(value) + else: + self._referencedsource = value + else: + self._referencedsource = value + return property(**locals()) + +#################### + # ENTITY ifcderivedunitelement # +#################### +class ifcderivedunitelement(BaseEntityClass): + '''Entity ifcderivedunitelement definition. + + :param unit + :type unit:ifcnamedunit + + :param exponent + :type exponent:INTEGER + ''' + def __init__( self , unit,exponent, ): + self.unit = unit + self.exponent = exponent + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unit is mantatory and can not be set to None') + if not check_type(value,ifcnamedunit): + self._unit = ifcnamedunit(value) + else: + self._unit = value + return property(**locals()) + + @apply + def exponent(): + def fget( self ): + return self._exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument exponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._exponent = INTEGER(value) + else: + self._exponent = value + return property(**locals()) + +#################### + # ENTITY ifcbuildingelement # +#################### +class ifcbuildingelement(ifcelement): + '''Entity ifcbuildingelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcrailing # +#################### +class ifcrailing(ifcbuildingelement): + '''Entity ifcrailing definition. + + :param predefinedtype + :type predefinedtype:ifcrailingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrailingtypeenum): + self._predefinedtype = ifcrailingtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def wr61(self): + eval_wr61_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcrailingtypeenum.self.userdefined)) or ((self.predefinedtype == ifcrailingtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_wr61_wr: + raise AssertionError('Rule wr61 violated') + else: + return eval_wr61_wr + + +#################### + # ENTITY ifccurrencyrelationship # +#################### +class ifccurrencyrelationship(BaseEntityClass): + '''Entity ifccurrencyrelationship definition. + + :param relatingmonetaryunit + :type relatingmonetaryunit:ifcmonetaryunit + + :param relatedmonetaryunit + :type relatedmonetaryunit:ifcmonetaryunit + + :param exchangerate + :type exchangerate:ifcpositiveratiomeasure + + :param ratedatetime + :type ratedatetime:ifcdateandtime + + :param ratesource + :type ratesource:ifclibraryinformation + ''' + def __init__( self , relatingmonetaryunit,relatedmonetaryunit,exchangerate,ratedatetime,ratesource, ): + self.relatingmonetaryunit = relatingmonetaryunit + self.relatedmonetaryunit = relatedmonetaryunit + self.exchangerate = exchangerate + self.ratedatetime = ratedatetime + self.ratesource = ratesource + + @apply + def relatingmonetaryunit(): + def fget( self ): + return self._relatingmonetaryunit + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingmonetaryunit is mantatory and can not be set to None') + if not check_type(value,ifcmonetaryunit): + self._relatingmonetaryunit = ifcmonetaryunit(value) + else: + self._relatingmonetaryunit = value + return property(**locals()) + + @apply + def relatedmonetaryunit(): + def fget( self ): + return self._relatedmonetaryunit + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedmonetaryunit is mantatory and can not be set to None') + if not check_type(value,ifcmonetaryunit): + self._relatedmonetaryunit = ifcmonetaryunit(value) + else: + self._relatedmonetaryunit = value + return property(**locals()) + + @apply + def exchangerate(): + def fget( self ): + return self._exchangerate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument exchangerate is mantatory and can not be set to None') + if not check_type(value,ifcpositiveratiomeasure): + self._exchangerate = ifcpositiveratiomeasure(value) + else: + self._exchangerate = value + return property(**locals()) + + @apply + def ratedatetime(): + def fget( self ): + return self._ratedatetime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ratedatetime is mantatory and can not be set to None') + if not check_type(value,ifcdateandtime): + self._ratedatetime = ifcdateandtime(value) + else: + self._ratedatetime = value + return property(**locals()) + + @apply + def ratesource(): + def fget( self ): + return self._ratesource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclibraryinformation): + self._ratesource = ifclibraryinformation(value) + else: + self._ratesource = value + else: + self._ratesource = value + return property(**locals()) + +#################### + # ENTITY ifcmaterial # +#################### +class ifcmaterial(BaseEntityClass): + '''Entity ifcmaterial definition. + + :param name + :type name:ifclabel + + :param hasrepresentation + :type hasrepresentation:SET(0,1,'ifcmaterialdefinitionrepresentation', scope = schema_scope) + + :param classifiedas + :type classifiedas:SET(0,1,'ifcmaterialclassificationrelationship', scope = schema_scope) + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def hasrepresentation(): + def fget( self ): + return self._hasrepresentation + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasrepresentation is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def classifiedas(): + def fget( self ): + return self._classifiedas + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument classifiedas is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcmember # +#################### +class ifcmember(ifcbuildingelement): + '''Entity ifcmember definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcprofileproperties # +#################### +class ifcprofileproperties(BaseEntityClass): + '''Entity ifcprofileproperties definition. + + :param profilename + :type profilename:ifclabel + + :param profiledefinition + :type profiledefinition:ifcprofiledef + ''' + def __init__( self , profilename,profiledefinition, ): + self.profilename = profilename + self.profiledefinition = profiledefinition + + @apply + def profilename(): + def fget( self ): + return self._profilename + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._profilename = ifclabel(value) + else: + self._profilename = value + else: + self._profilename = value + return property(**locals()) + + @apply + def profiledefinition(): + def fget( self ): + return self._profiledefinition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcprofiledef): + self._profiledefinition = ifcprofiledef(value) + else: + self._profiledefinition = value + else: + self._profiledefinition = value + return property(**locals()) + +#################### + # ENTITY ifcgeneralprofileproperties # +#################### +class ifcgeneralprofileproperties(ifcprofileproperties): + '''Entity ifcgeneralprofileproperties definition. + + :param physicalweight + :type physicalweight:ifcmassperlengthmeasure + + :param perimeter + :type perimeter:ifcpositivelengthmeasure + + :param minimumplatethickness + :type minimumplatethickness:ifcpositivelengthmeasure + + :param maximumplatethickness + :type maximumplatethickness:ifcpositivelengthmeasure + + :param crosssectionarea + :type crosssectionarea:ifcareameasure + ''' + def __init__( self , inherited0__profilename , inherited1__profiledefinition , physicalweight,perimeter,minimumplatethickness,maximumplatethickness,crosssectionarea, ): + ifcprofileproperties.__init__(self , inherited0__profilename , inherited1__profiledefinition , ) + self.physicalweight = physicalweight + self.perimeter = perimeter + self.minimumplatethickness = minimumplatethickness + self.maximumplatethickness = maximumplatethickness + self.crosssectionarea = crosssectionarea + + @apply + def physicalweight(): + def fget( self ): + return self._physicalweight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmassperlengthmeasure): + self._physicalweight = ifcmassperlengthmeasure(value) + else: + self._physicalweight = value + else: + self._physicalweight = value + return property(**locals()) + + @apply + def perimeter(): + def fget( self ): + return self._perimeter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._perimeter = ifcpositivelengthmeasure(value) + else: + self._perimeter = value + else: + self._perimeter = value + return property(**locals()) + + @apply + def minimumplatethickness(): + def fget( self ): + return self._minimumplatethickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._minimumplatethickness = ifcpositivelengthmeasure(value) + else: + self._minimumplatethickness = value + else: + self._minimumplatethickness = value + return property(**locals()) + + @apply + def maximumplatethickness(): + def fget( self ): + return self._maximumplatethickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._maximumplatethickness = ifcpositivelengthmeasure(value) + else: + self._maximumplatethickness = value + else: + self._maximumplatethickness = value + return property(**locals()) + + @apply + def crosssectionarea(): + def fget( self ): + return self._crosssectionarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._crosssectionarea = ifcareameasure(value) + else: + self._crosssectionarea = value + else: + self._crosssectionarea = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not EXISTS(self.crosssectionarea)) or (self.crosssectionarea > 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcstructuralprofileproperties # +#################### +class ifcstructuralprofileproperties(ifcgeneralprofileproperties): + '''Entity ifcstructuralprofileproperties definition. + + :param torsionalconstantx + :type torsionalconstantx:ifcmomentofinertiameasure + + :param momentofinertiayz + :type momentofinertiayz:ifcmomentofinertiameasure + + :param momentofinertiay + :type momentofinertiay:ifcmomentofinertiameasure + + :param momentofinertiaz + :type momentofinertiaz:ifcmomentofinertiameasure + + :param warpingconstant + :type warpingconstant:ifcwarpingconstantmeasure + + :param shearcentrez + :type shearcentrez:ifclengthmeasure + + :param shearcentrey + :type shearcentrey:ifclengthmeasure + + :param sheardeformationareaz + :type sheardeformationareaz:ifcareameasure + + :param sheardeformationareay + :type sheardeformationareay:ifcareameasure + + :param maximumsectionmodulusy + :type maximumsectionmodulusy:ifcsectionmodulusmeasure + + :param minimumsectionmodulusy + :type minimumsectionmodulusy:ifcsectionmodulusmeasure + + :param maximumsectionmodulusz + :type maximumsectionmodulusz:ifcsectionmodulusmeasure + + :param minimumsectionmodulusz + :type minimumsectionmodulusz:ifcsectionmodulusmeasure + + :param torsionalsectionmodulus + :type torsionalsectionmodulus:ifcsectionmodulusmeasure + + :param centreofgravityinx + :type centreofgravityinx:ifclengthmeasure + + :param centreofgravityiny + :type centreofgravityiny:ifclengthmeasure + ''' + def __init__( self , inherited0__profilename , inherited1__profiledefinition , inherited2__physicalweight , inherited3__perimeter , inherited4__minimumplatethickness , inherited5__maximumplatethickness , inherited6__crosssectionarea , torsionalconstantx,momentofinertiayz,momentofinertiay,momentofinertiaz,warpingconstant,shearcentrez,shearcentrey,sheardeformationareaz,sheardeformationareay,maximumsectionmodulusy,minimumsectionmodulusy,maximumsectionmodulusz,minimumsectionmodulusz,torsionalsectionmodulus,centreofgravityinx,centreofgravityiny, ): + ifcgeneralprofileproperties.__init__(self , inherited0__profilename , inherited1__profiledefinition , inherited2__physicalweight , inherited3__perimeter , inherited4__minimumplatethickness , inherited5__maximumplatethickness , inherited6__crosssectionarea , ) + self.torsionalconstantx = torsionalconstantx + self.momentofinertiayz = momentofinertiayz + self.momentofinertiay = momentofinertiay + self.momentofinertiaz = momentofinertiaz + self.warpingconstant = warpingconstant + self.shearcentrez = shearcentrez + self.shearcentrey = shearcentrey + self.sheardeformationareaz = sheardeformationareaz + self.sheardeformationareay = sheardeformationareay + self.maximumsectionmodulusy = maximumsectionmodulusy + self.minimumsectionmodulusy = minimumsectionmodulusy + self.maximumsectionmodulusz = maximumsectionmodulusz + self.minimumsectionmodulusz = minimumsectionmodulusz + self.torsionalsectionmodulus = torsionalsectionmodulus + self.centreofgravityinx = centreofgravityinx + self.centreofgravityiny = centreofgravityiny + + @apply + def torsionalconstantx(): + def fget( self ): + return self._torsionalconstantx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmomentofinertiameasure): + self._torsionalconstantx = ifcmomentofinertiameasure(value) + else: + self._torsionalconstantx = value + else: + self._torsionalconstantx = value + return property(**locals()) + + @apply + def momentofinertiayz(): + def fget( self ): + return self._momentofinertiayz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmomentofinertiameasure): + self._momentofinertiayz = ifcmomentofinertiameasure(value) + else: + self._momentofinertiayz = value + else: + self._momentofinertiayz = value + return property(**locals()) + + @apply + def momentofinertiay(): + def fget( self ): + return self._momentofinertiay + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmomentofinertiameasure): + self._momentofinertiay = ifcmomentofinertiameasure(value) + else: + self._momentofinertiay = value + else: + self._momentofinertiay = value + return property(**locals()) + + @apply + def momentofinertiaz(): + def fget( self ): + return self._momentofinertiaz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmomentofinertiameasure): + self._momentofinertiaz = ifcmomentofinertiameasure(value) + else: + self._momentofinertiaz = value + else: + self._momentofinertiaz = value + return property(**locals()) + + @apply + def warpingconstant(): + def fget( self ): + return self._warpingconstant + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcwarpingconstantmeasure): + self._warpingconstant = ifcwarpingconstantmeasure(value) + else: + self._warpingconstant = value + else: + self._warpingconstant = value + return property(**locals()) + + @apply + def shearcentrez(): + def fget( self ): + return self._shearcentrez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._shearcentrez = ifclengthmeasure(value) + else: + self._shearcentrez = value + else: + self._shearcentrez = value + return property(**locals()) + + @apply + def shearcentrey(): + def fget( self ): + return self._shearcentrey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._shearcentrey = ifclengthmeasure(value) + else: + self._shearcentrey = value + else: + self._shearcentrey = value + return property(**locals()) + + @apply + def sheardeformationareaz(): + def fget( self ): + return self._sheardeformationareaz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._sheardeformationareaz = ifcareameasure(value) + else: + self._sheardeformationareaz = value + else: + self._sheardeformationareaz = value + return property(**locals()) + + @apply + def sheardeformationareay(): + def fget( self ): + return self._sheardeformationareay + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._sheardeformationareay = ifcareameasure(value) + else: + self._sheardeformationareay = value + else: + self._sheardeformationareay = value + return property(**locals()) + + @apply + def maximumsectionmodulusy(): + def fget( self ): + return self._maximumsectionmodulusy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsectionmodulusmeasure): + self._maximumsectionmodulusy = ifcsectionmodulusmeasure(value) + else: + self._maximumsectionmodulusy = value + else: + self._maximumsectionmodulusy = value + return property(**locals()) + + @apply + def minimumsectionmodulusy(): + def fget( self ): + return self._minimumsectionmodulusy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsectionmodulusmeasure): + self._minimumsectionmodulusy = ifcsectionmodulusmeasure(value) + else: + self._minimumsectionmodulusy = value + else: + self._minimumsectionmodulusy = value + return property(**locals()) + + @apply + def maximumsectionmodulusz(): + def fget( self ): + return self._maximumsectionmodulusz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsectionmodulusmeasure): + self._maximumsectionmodulusz = ifcsectionmodulusmeasure(value) + else: + self._maximumsectionmodulusz = value + else: + self._maximumsectionmodulusz = value + return property(**locals()) + + @apply + def minimumsectionmodulusz(): + def fget( self ): + return self._minimumsectionmodulusz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsectionmodulusmeasure): + self._minimumsectionmodulusz = ifcsectionmodulusmeasure(value) + else: + self._minimumsectionmodulusz = value + else: + self._minimumsectionmodulusz = value + return property(**locals()) + + @apply + def torsionalsectionmodulus(): + def fget( self ): + return self._torsionalsectionmodulus + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsectionmodulusmeasure): + self._torsionalsectionmodulus = ifcsectionmodulusmeasure(value) + else: + self._torsionalsectionmodulus = value + else: + self._torsionalsectionmodulus = value + return property(**locals()) + + @apply + def centreofgravityinx(): + def fget( self ): + return self._centreofgravityinx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._centreofgravityinx = ifclengthmeasure(value) + else: + self._centreofgravityinx = value + else: + self._centreofgravityinx = value + return property(**locals()) + + @apply + def centreofgravityiny(): + def fget( self ): + return self._centreofgravityiny + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._centreofgravityiny = ifclengthmeasure(value) + else: + self._centreofgravityiny = value + else: + self._centreofgravityiny = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.sheardeformationareay)) or (self.sheardeformationareay >= 0)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (( not EXISTS(self.sheardeformationareaz)) or (self.sheardeformationareaz >= 0)) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcpropertyconstraintrelationship # +#################### +class ifcpropertyconstraintrelationship(BaseEntityClass): + '''Entity ifcpropertyconstraintrelationship definition. + + :param relatingconstraint + :type relatingconstraint:ifcconstraint + + :param relatedproperties + :type relatedproperties:SET(1,None,'ifcproperty', scope = schema_scope) + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + ''' + def __init__( self , relatingconstraint,relatedproperties,name,description, ): + self.relatingconstraint = relatingconstraint + self.relatedproperties = relatedproperties + self.name = name + self.description = description + + @apply + def relatingconstraint(): + def fget( self ): + return self._relatingconstraint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingconstraint is mantatory and can not be set to None') + if not check_type(value,ifcconstraint): + self._relatingconstraint = ifcconstraint(value) + else: + self._relatingconstraint = value + return property(**locals()) + + @apply + def relatedproperties(): + def fget( self ): + return self._relatedproperties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedproperties is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproperty', scope = schema_scope)): + self._relatedproperties = SET(value) + else: + self._relatedproperties = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY ifccurve # +#################### +class ifccurve(ifcgeometricrepresentationitem): + '''Entity ifccurve definition. + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + + @apply + def dim(): + def fget( self ): + attribute_eval = ifccurvedim(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcboundedcurve # +#################### +class ifcboundedcurve(ifccurve): + '''Entity ifcboundedcurve definition. + ''' + def __init__( self , ): + ifccurve.__init__(self , ) + +#################### + # ENTITY ifcbsplinecurve # +#################### +class ifcbsplinecurve(ifcboundedcurve): + '''Entity ifcbsplinecurve definition. + + :param degree + :type degree:INTEGER + + :param controlpointslist + :type controlpointslist:LIST(2,None,'ifccartesianpoint', scope = schema_scope) + + :param curveform + :type curveform:ifcbsplinecurveform + + :param closedcurve + :type closedcurve:LOGICAL + + :param selfintersect + :type selfintersect:LOGICAL + + :param controlpoints + :type controlpoints:ARRAY(0,255,'ifccartesianpoint', scope = schema_scope) + + :param upperindexoncontrolpoints + :type upperindexoncontrolpoints:INTEGER + ''' + def __init__( self , degree,controlpointslist,curveform,closedcurve,selfintersect, ): + ifcboundedcurve.__init__(self , ) + self.degree = degree + self.controlpointslist = controlpointslist + self.curveform = curveform + self.closedcurve = closedcurve + self.selfintersect = selfintersect + + @apply + def degree(): + def fget( self ): + return self._degree + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument degree is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._degree = INTEGER(value) + else: + self._degree = value + return property(**locals()) + + @apply + def controlpointslist(): + def fget( self ): + return self._controlpointslist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument controlpointslist is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'ifccartesianpoint', scope = schema_scope)): + self._controlpointslist = LIST(value) + else: + self._controlpointslist = value + return property(**locals()) + + @apply + def curveform(): + def fget( self ): + return self._curveform + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curveform is mantatory and can not be set to None') + if not check_type(value,ifcbsplinecurveform): + self._curveform = ifcbsplinecurveform(value) + else: + self._curveform = value + return property(**locals()) + + @apply + def closedcurve(): + def fget( self ): + return self._closedcurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument closedcurve is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._closedcurve = LOGICAL(value) + else: + self._closedcurve = value + return property(**locals()) + + @apply + def selfintersect(): + def fget( self ): + return self._selfintersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument selfintersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._selfintersect = LOGICAL(value) + else: + self._selfintersect = value + return property(**locals()) + + @apply + def controlpoints(): + def fget( self ): + attribute_eval = ifclisttoarray(self.controlpointslist,0,self.upperindexoncontrolpoints) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument controlpoints is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def upperindexoncontrolpoints(): + def fget( self ): + attribute_eval = (SIZEOF(self.controlpointslist) - 1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument upperindexoncontrolpoints is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr41(self): + eval_wr41_wr = (SIZEOF(None) == 0) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + +#################### + # ENTITY ifcbeziercurve # +#################### +class ifcbeziercurve(ifcbsplinecurve): + '''Entity ifcbeziercurve definition. + ''' + def __init__( self , inherited0__degree , inherited1__controlpointslist , inherited2__curveform , inherited3__closedcurve , inherited4__selfintersect , ): + ifcbsplinecurve.__init__(self , inherited0__degree , inherited1__controlpointslist , inherited2__curveform , inherited3__closedcurve , inherited4__selfintersect , ) + +#################### + # ENTITY ifcrationalbeziercurve # +#################### +class ifcrationalbeziercurve(ifcbeziercurve): + '''Entity ifcrationalbeziercurve definition. + + :param weightsdata + :type weightsdata:LIST(2,None,'REAL', scope = schema_scope) + + :param weights + :type weights:ARRAY(0,255,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__degree , inherited1__controlpointslist , inherited2__curveform , inherited3__closedcurve , inherited4__selfintersect , weightsdata, ): + ifcbeziercurve.__init__(self , inherited0__degree , inherited1__controlpointslist , inherited2__curveform , inherited3__closedcurve , inherited4__selfintersect , ) + self.weightsdata = weightsdata + + @apply + def weightsdata(): + def fget( self ): + return self._weightsdata + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument weightsdata is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._weightsdata = LIST(value) + else: + self._weightsdata = value + return property(**locals()) + + @apply + def weights(): + def fget( self ): + attribute_eval = ifclisttoarray(self.weightsdata,0,self.self.ifcbsplinecurve.self.upperindexoncontrolpoints) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument weights is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.weightsdata) == SIZEOF(self.self.ifcbsplinecurve.self.controlpointslist)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ifccurveweightspositive(self) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcgroup # +#################### +class ifcgroup(ifcobject): + '''Entity ifcgroup definition. + + :param isgroupedby + :type isgroupedby:ifcrelassignstogroup + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + + @apply + def isgroupedby(): + def fget( self ): + return self._isgroupedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isgroupedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsystem # +#################### +class ifcsystem(ifcgroup): + '''Entity ifcsystem definition. + + :param servicesbuildings + :type servicesbuildings:SET(0,1,'ifcrelservicesbuildings', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + + @apply + def servicesbuildings(): + def fget( self ): + return self._servicesbuildings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument servicesbuildings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcannotationfillarea # +#################### +class ifcannotationfillarea(ifcgeometricrepresentationitem): + '''Entity ifcannotationfillarea definition. + + :param outerboundary + :type outerboundary:ifccurve + + :param innerboundaries + :type innerboundaries:SET(1,None,'ifccurve', scope = schema_scope) + ''' + def __init__( self , outerboundary,innerboundaries, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.outerboundary = outerboundary + self.innerboundaries = innerboundaries + + @apply + def outerboundary(): + def fget( self ): + return self._outerboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument outerboundary is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._outerboundary = ifccurve(value) + else: + self._outerboundary = value + return property(**locals()) + + @apply + def innerboundaries(): + def fget( self ): + return self._innerboundaries + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifccurve', scope = schema_scope)): + self._innerboundaries = SET(value) + else: + self._innerboundaries = value + else: + self._innerboundaries = value + return property(**locals()) + +#################### + # ENTITY ifcelectricalcircuit # +#################### +class ifcelectricalcircuit(ifcsystem): + '''Entity ifcelectricalcircuit definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcsystem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + +#################### + # ENTITY ifcdoorpanelproperties # +#################### +class ifcdoorpanelproperties(ifcpropertysetdefinition): + '''Entity ifcdoorpanelproperties definition. + + :param paneldepth + :type paneldepth:ifcpositivelengthmeasure + + :param paneloperation + :type paneloperation:ifcdoorpaneloperationenum + + :param panelwidth + :type panelwidth:ifcnormalisedratiomeasure + + :param panelposition + :type panelposition:ifcdoorpanelpositionenum + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , paneldepth,paneloperation,panelwidth,panelposition,shapeaspectstyle, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.paneldepth = paneldepth + self.paneloperation = paneloperation + self.panelwidth = panelwidth + self.panelposition = panelposition + self.shapeaspectstyle = shapeaspectstyle + + @apply + def paneldepth(): + def fget( self ): + return self._paneldepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._paneldepth = ifcpositivelengthmeasure(value) + else: + self._paneldepth = value + else: + self._paneldepth = value + return property(**locals()) + + @apply + def paneloperation(): + def fget( self ): + return self._paneloperation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument paneloperation is mantatory and can not be set to None') + if not check_type(value,ifcdoorpaneloperationenum): + self._paneloperation = ifcdoorpaneloperationenum(value) + else: + self._paneloperation = value + return property(**locals()) + + @apply + def panelwidth(): + def fget( self ): + return self._panelwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._panelwidth = ifcnormalisedratiomeasure(value) + else: + self._panelwidth = value + else: + self._panelwidth = value + return property(**locals()) + + @apply + def panelposition(): + def fget( self ): + return self._panelposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument panelposition is mantatory and can not be set to None') + if not check_type(value,ifcdoorpanelpositionenum): + self._panelposition = ifcdoorpanelpositionenum(value) + else: + self._panelposition = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (EXISTS(self.self.ifcpropertysetdefinition.self.definestype[1]) and ('IFC2X3.IFCDOORSTYLE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1]))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcpermeablecoveringproperties # +#################### +class ifcpermeablecoveringproperties(ifcpropertysetdefinition): + '''Entity ifcpermeablecoveringproperties definition. + + :param operationtype + :type operationtype:ifcpermeablecoveringoperationenum + + :param panelposition + :type panelposition:ifcwindowpanelpositionenum + + :param framedepth + :type framedepth:ifcpositivelengthmeasure + + :param framethickness + :type framethickness:ifcpositivelengthmeasure + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , operationtype,panelposition,framedepth,framethickness,shapeaspectstyle, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.operationtype = operationtype + self.panelposition = panelposition + self.framedepth = framedepth + self.framethickness = framethickness + self.shapeaspectstyle = shapeaspectstyle + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operationtype is mantatory and can not be set to None') + if not check_type(value,ifcpermeablecoveringoperationenum): + self._operationtype = ifcpermeablecoveringoperationenum(value) + else: + self._operationtype = value + return property(**locals()) + + @apply + def panelposition(): + def fget( self ): + return self._panelposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument panelposition is mantatory and can not be set to None') + if not check_type(value,ifcwindowpanelpositionenum): + self._panelposition = ifcwindowpanelpositionenum(value) + else: + self._panelposition = value + return property(**locals()) + + @apply + def framedepth(): + def fget( self ): + return self._framedepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._framedepth = ifcpositivelengthmeasure(value) + else: + self._framedepth = value + else: + self._framedepth = value + return property(**locals()) + + @apply + def framethickness(): + def fget( self ): + return self._framethickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._framethickness = ifcpositivelengthmeasure(value) + else: + self._framethickness = value + else: + self._framethickness = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + +#################### + # ENTITY ifcservicelifefactor # +#################### +class ifcservicelifefactor(ifcpropertysetdefinition): + '''Entity ifcservicelifefactor definition. + + :param predefinedtype + :type predefinedtype:ifcservicelifefactortypeenum + + :param uppervalue + :type uppervalue:ifcmeasurevalue + + :param mostusedvalue + :type mostusedvalue:ifcmeasurevalue + + :param lowervalue + :type lowervalue:ifcmeasurevalue + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , predefinedtype,uppervalue,mostusedvalue,lowervalue, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.predefinedtype = predefinedtype + self.uppervalue = uppervalue + self.mostusedvalue = mostusedvalue + self.lowervalue = lowervalue + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcservicelifefactortypeenum): + self._predefinedtype = ifcservicelifefactortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def uppervalue(): + def fget( self ): + return self._uppervalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmeasurevalue): + self._uppervalue = ifcmeasurevalue(value) + else: + self._uppervalue = value + else: + self._uppervalue = value + return property(**locals()) + + @apply + def mostusedvalue(): + def fget( self ): + return self._mostusedvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mostusedvalue is mantatory and can not be set to None') + if not check_type(value,ifcmeasurevalue): + self._mostusedvalue = ifcmeasurevalue(value) + else: + self._mostusedvalue = value + return property(**locals()) + + @apply + def lowervalue(): + def fget( self ): + return self._lowervalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmeasurevalue): + self._lowervalue = ifcmeasurevalue(value) + else: + self._lowervalue = value + else: + self._lowervalue = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (( not (self.predefinedtype == ifcservicelifefactortypeenum.self.userdefined)) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcflowcontrollertype # +#################### +class ifcflowcontrollertype(ifcdistributionflowelementtype): + '''Entity ifcflowcontrollertype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcvalvetype # +#################### +class ifcvalvetype(ifcflowcontrollertype): + '''Entity ifcvalvetype definition. + + :param predefinedtype + :type predefinedtype:ifcvalvetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcvalvetypeenum): + self._predefinedtype = ifcvalvetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcvalvetypeenum.self.userdefined) or ((self.predefinedtype == ifcvalvetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcsolidmodel # +#################### +class ifcsolidmodel(ifcgeometricrepresentationitem): + '''Entity ifcsolidmodel definition. + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsweptareasolid # +#################### +class ifcsweptareasolid(ifcsolidmodel): + '''Entity ifcsweptareasolid definition. + + :param sweptarea + :type sweptarea:ifcprofiledef + + :param position + :type position:ifcaxis2placement3d + ''' + def __init__( self , sweptarea,position, ): + ifcsolidmodel.__init__(self , ) + self.sweptarea = sweptarea + self.position = position + + @apply + def sweptarea(): + def fget( self ): + return self._sweptarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sweptarea is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._sweptarea = ifcprofiledef(value) + else: + self._sweptarea = value + return property(**locals()) + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + def wr22(self): + eval_wr22_wr = (self.sweptarea.self.profiletype == ifcprofiletypeenum.self.area) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcrevolvedareasolid # +#################### +class ifcrevolvedareasolid(ifcsweptareasolid): + '''Entity ifcrevolvedareasolid definition. + + :param axis + :type axis:ifcaxis1placement + + :param angle + :type angle:ifcplaneanglemeasure + + :param axisline + :type axisline:ifcline + ''' + def __init__( self , inherited0__sweptarea , inherited1__position , axis,angle, ): + ifcsweptareasolid.__init__(self , inherited0__sweptarea , inherited1__position , ) + self.axis = axis + self.angle = angle + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axis is mantatory and can not be set to None') + if not check_type(value,ifcaxis1placement): + self._axis = ifcaxis1placement(value) + else: + self._axis = value + return property(**locals()) + + @apply + def angle(): + def fget( self ): + return self._angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument angle is mantatory and can not be set to None') + if not check_type(value,ifcplaneanglemeasure): + self._angle = ifcplaneanglemeasure(value) + else: + self._angle = value + return property(**locals()) + + @apply + def axisline(): + def fget( self ): + attribute_eval = (((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifccurve()) == ifcline(self.axis.self.location,(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(self.axis.self.z,1))) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument axisline is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr31(self): + eval_wr31_wr = (self.axis.self.location.self.coordinates[3] == 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = (self.axis.self.z.self.directionratios[3] == 0) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + +#################### + # ENTITY ifctexturecoordinate # +#################### +class ifctexturecoordinate(BaseEntityClass): + '''Entity ifctexturecoordinate definition. + + :param annotatedsurface + :type annotatedsurface:SET(1,1,'ifcannotationsurface', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def annotatedsurface(): + def fget( self ): + return self._annotatedsurface + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument annotatedsurface is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifctexturemap # +#################### +class ifctexturemap(ifctexturecoordinate): + '''Entity ifctexturemap definition. + + :param texturemaps + :type texturemaps:SET(1,None,'ifcvertexbasedtexturemap', scope = schema_scope) + ''' + def __init__( self , texturemaps, ): + ifctexturecoordinate.__init__(self , ) + self.texturemaps = texturemaps + + @apply + def texturemaps(): + def fget( self ): + return self._texturemaps + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument texturemaps is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcvertexbasedtexturemap', scope = schema_scope)): + self._texturemaps = SET(value) + else: + self._texturemaps = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (SIZEOF(['IFC2X3.IFCSHELLBASEDSURFACEMODEL','IFC2X3.IFCFACEBASEDSURFACEMODEL','IFC2X3.IFCFACETEDBREP','IFC2X3.IFCFACETEDBREPWITHVOIDS'] * TYPEOF(self.self.ifctexturecoordinate.self.annotatedsurface[1].self.item)) >= 1) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcairterminalboxtype # +#################### +class ifcairterminalboxtype(ifcflowcontrollertype): + '''Entity ifcairterminalboxtype definition. + + :param predefinedtype + :type predefinedtype:ifcairterminalboxtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcairterminalboxtypeenum): + self._predefinedtype = ifcairterminalboxtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcairterminalboxtypeenum.self.userdefined) or ((self.predefinedtype == ifcairterminalboxtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcboundarycondition # +#################### +class ifcboundarycondition(BaseEntityClass): + '''Entity ifcboundarycondition definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcbuildingelementtype # +#################### +class ifcbuildingelementtype(ifcelementtype): + '''Entity ifcbuildingelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcbuildingelementproxytype # +#################### +class ifcbuildingelementproxytype(ifcbuildingelementtype): + '''Entity ifcbuildingelementproxytype definition. + + :param predefinedtype + :type predefinedtype:ifcbuildingelementproxytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcbuildingelementproxytypeenum): + self._predefinedtype = ifcbuildingelementproxytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcpresentationstyle # +#################### +class ifcpresentationstyle(BaseEntityClass): + '''Entity ifcpresentationstyle definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcfillareastyle # +#################### +class ifcfillareastyle(ifcpresentationstyle): + '''Entity ifcfillareastyle definition. + + :param fillstyles + :type fillstyles:SET(1,None,'ifcfillstyleselect', scope = schema_scope) + ''' + def __init__( self , inherited0__name , fillstyles, ): + ifcpresentationstyle.__init__(self , inherited0__name , ) + self.fillstyles = fillstyles + + @apply + def fillstyles(): + def fget( self ): + return self._fillstyles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fillstyles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcfillstyleselect', scope = schema_scope)): + self._fillstyles = SET(value) + else: + self._fillstyles = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (SIZEOF(None) <= 1) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(None) <= 1) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = ifccorrectfillareastyle(self.self.fillstyles) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + +#################### + # ENTITY ifccsgsolid # +#################### +class ifccsgsolid(ifcsolidmodel): + '''Entity ifccsgsolid definition. + + :param treerootexpression + :type treerootexpression:ifccsgselect + ''' + def __init__( self , treerootexpression, ): + ifcsolidmodel.__init__(self , ) + self.treerootexpression = treerootexpression + + @apply + def treerootexpression(): + def fget( self ): + return self._treerootexpression + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument treerootexpression is mantatory and can not be set to None') + if not check_type(value,ifccsgselect): + self._treerootexpression = ifccsgselect(value) + else: + self._treerootexpression = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacetexture # +#################### +class ifcsurfacetexture(BaseEntityClass): + '''Entity ifcsurfacetexture definition. + + :param repeats + :type repeats:BOOLEAN + + :param repeatt + :type repeatt:BOOLEAN + + :param texturetype + :type texturetype:ifcsurfacetextureenum + + :param texturetransform + :type texturetransform:ifccartesiantransformationoperator2d + ''' + def __init__( self , repeats,repeatt,texturetype,texturetransform, ): + self.repeats = repeats + self.repeatt = repeatt + self.texturetype = texturetype + self.texturetransform = texturetransform + + @apply + def repeats(): + def fget( self ): + return self._repeats + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument repeats is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._repeats = BOOLEAN(value) + else: + self._repeats = value + return property(**locals()) + + @apply + def repeatt(): + def fget( self ): + return self._repeatt + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument repeatt is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._repeatt = BOOLEAN(value) + else: + self._repeatt = value + return property(**locals()) + + @apply + def texturetype(): + def fget( self ): + return self._texturetype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument texturetype is mantatory and can not be set to None') + if not check_type(value,ifcsurfacetextureenum): + self._texturetype = ifcsurfacetextureenum(value) + else: + self._texturetype = value + return property(**locals()) + + @apply + def texturetransform(): + def fget( self ): + return self._texturetransform + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccartesiantransformationoperator2d): + self._texturetransform = ifccartesiantransformationoperator2d(value) + else: + self._texturetransform = value + else: + self._texturetransform = value + return property(**locals()) + +#################### + # ENTITY ifcpixeltexture # +#################### +class ifcpixeltexture(ifcsurfacetexture): + '''Entity ifcpixeltexture definition. + + :param width + :type width:ifcinteger + + :param height + :type height:ifcinteger + + :param colourcomponents + :type colourcomponents:ifcinteger + + :param pixel + :type pixel:LIST(1,None,'(null)', scope = schema_scope) + ''' + def __init__( self , inherited0__repeats , inherited1__repeatt , inherited2__texturetype , inherited3__texturetransform , width,height,colourcomponents,pixel, ): + ifcsurfacetexture.__init__(self , inherited0__repeats , inherited1__repeatt , inherited2__texturetype , inherited3__texturetransform , ) + self.width = width + self.height = height + self.colourcomponents = colourcomponents + self.pixel = pixel + + @apply + def width(): + def fget( self ): + return self._width + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument width is mantatory and can not be set to None') + if not check_type(value,ifcinteger): + self._width = ifcinteger(value) + else: + self._width = value + return property(**locals()) + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,ifcinteger): + self._height = ifcinteger(value) + else: + self._height = value + return property(**locals()) + + @apply + def colourcomponents(): + def fget( self ): + return self._colourcomponents + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colourcomponents is mantatory and can not be set to None') + if not check_type(value,ifcinteger): + self._colourcomponents = ifcinteger(value) + else: + self._colourcomponents = value + return property(**locals()) + + @apply + def pixel(): + def fget( self ): + return self._pixel + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pixel is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'(null)', scope = schema_scope)): + self._pixel = LIST(value) + else: + self._pixel = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (self.width >= 1) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.height >= 1) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + def wr23(self): + eval_wr23_wr = ((1 <= self.colourcomponents) and (self.colourcomponents <= 4)) + if not eval_wr23_wr: + raise AssertionError('Rule wr23 violated') + else: + return eval_wr23_wr + + def wr24(self): + eval_wr24_wr = (SIZEOF(self.pixel) == (self.width * self.height)) + if not eval_wr24_wr: + raise AssertionError('Rule wr24 violated') + else: + return eval_wr24_wr + + +#################### + # ENTITY ifcrelassociates # +#################### +class ifcrelassociates(ifcrelationship): + '''Entity ifcrelassociates definition. + + :param relatedobjects + :type relatedobjects:SET(1,None,'ifcroot', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedobjects, ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedobjects = relatedobjects + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcroot', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcreldecomposes # +#################### +class ifcreldecomposes(ifcrelationship): + '''Entity ifcreldecomposes definition. + + :param relatingobject + :type relatingobject:ifcobjectdefinition + + :param relatedobjects + :type relatedobjects:SET(1,None,'ifcobjectdefinition', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingobject,relatedobjects, ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingobject = relatingobject + self.relatedobjects = relatedobjects + + @apply + def relatingobject(): + def fget( self ): + return self._relatingobject + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingobject is mantatory and can not be set to None') + if not check_type(value,ifcobjectdefinition): + self._relatingobject = ifcobjectdefinition(value) + else: + self._relatingobject = value + return property(**locals()) + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcobjectdefinition', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (SIZEOF(None) == 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcrelnests # +#################### +class ifcrelnests(ifcreldecomposes): + '''Entity ifcrelnests definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingobject , inherited5__relatedobjects , ): + ifcreldecomposes.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingobject , inherited5__relatedobjects , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcspatialstructureelementtype # +#################### +class ifcspatialstructureelementtype(ifcelementtype): + '''Entity ifcspatialstructureelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcspacetype # +#################### +class ifcspacetype(ifcspatialstructureelementtype): + '''Entity ifcspacetype definition. + + :param predefinedtype + :type predefinedtype:ifcspacetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcspatialstructureelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcspacetypeenum): + self._predefinedtype = ifcspacetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcplacement # +#################### +class ifcplacement(ifcgeometricrepresentationitem): + '''Entity ifcplacement definition. + + :param location + :type location:ifccartesianpoint + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , location, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.location = location + + @apply + def location(): + def fget( self ): + return self._location + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument location is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._location = ifccartesianpoint(value) + else: + self._location = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.location.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcaxis1placement # +#################### +class ifcaxis1placement(ifcplacement): + '''Entity ifcaxis1placement definition. + + :param axis + :type axis:ifcdirection + + :param z + :type z:ifcdirection + ''' + def __init__( self , inherited0__location , axis, ): + ifcplacement.__init__(self , inherited0__location , ) + self.axis = axis + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis = ifcdirection(value) + else: + self._axis = value + else: + self._axis = value + return property(**locals()) + + @apply + def z(): + def fget( self ): + attribute_eval = NVL(ifcnormalise(self.axis),(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,0,1])) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument z is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not EXISTS(self.axis)) or (self.axis.self.dim == 3)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.ifcplacement.self.location.self.dim == 3) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcelectricgeneratortype # +#################### +class ifcelectricgeneratortype(ifcenergyconversiondevicetype): + '''Entity ifcelectricgeneratortype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricgeneratortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricgeneratortypeenum): + self._predefinedtype = ifcelectricgeneratortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcflowfittingtype # +#################### +class ifcflowfittingtype(ifcdistributionflowelementtype): + '''Entity ifcflowfittingtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcpipefittingtype # +#################### +class ifcpipefittingtype(ifcflowfittingtype): + '''Entity ifcpipefittingtype definition. + + :param predefinedtype + :type predefinedtype:ifcpipefittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowfittingtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcpipefittingtypeenum): + self._predefinedtype = ifcpipefittingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcpipefittingtypeenum.self.userdefined) or ((self.predefinedtype == ifcpipefittingtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcstructuralconnection # +#################### +class ifcstructuralconnection(ifcstructuralitem): + '''Entity ifcstructuralconnection definition. + + :param appliedcondition + :type appliedcondition:ifcboundarycondition + + :param connectsstructuralmembers + :type connectsstructuralmembers:SET(1,None,'ifcrelconnectsstructuralmember', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , appliedcondition, ): + ifcstructuralitem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.appliedcondition = appliedcondition + + @apply + def appliedcondition(): + def fget( self ): + return self._appliedcondition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcboundarycondition): + self._appliedcondition = ifcboundarycondition(value) + else: + self._appliedcondition = value + else: + self._appliedcondition = value + return property(**locals()) + + @apply + def connectsstructuralmembers(): + def fget( self ): + return self._connectsstructuralmembers + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectsstructuralmembers is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcfillareastyletilesymbolwithstyle # +#################### +class ifcfillareastyletilesymbolwithstyle(ifcgeometricrepresentationitem): + '''Entity ifcfillareastyletilesymbolwithstyle definition. + + :param symbol + :type symbol:ifcannotationsymboloccurrence + ''' + def __init__( self , symbol, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.symbol = symbol + + @apply + def symbol(): + def fget( self ): + return self._symbol + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument symbol is mantatory and can not be set to None') + if not check_type(value,ifcannotationsymboloccurrence): + self._symbol = ifcannotationsymboloccurrence(value) + else: + self._symbol = value + return property(**locals()) + +#################### + # ENTITY ifcflowterminaltype # +#################### +class ifcflowterminaltype(ifcdistributionflowelementtype): + '''Entity ifcflowterminaltype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcwasteterminaltype # +#################### +class ifcwasteterminaltype(ifcflowterminaltype): + '''Entity ifcwasteterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcwasteterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcwasteterminaltypeenum): + self._predefinedtype = ifcwasteterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcdistributionelement # +#################### +class ifcdistributionelement(ifcelement): + '''Entity ifcdistributionelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcdistributioncontrolelement # +#################### +class ifcdistributioncontrolelement(ifcdistributionelement): + '''Entity ifcdistributioncontrolelement definition. + + :param controlelementid + :type controlelementid:ifcidentifier + + :param assignedtoflowelement + :type assignedtoflowelement:SET(0,1,'ifcrelflowcontrolelements', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , controlelementid, ): + ifcdistributionelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.controlelementid = controlelementid + + @apply + def controlelementid(): + def fget( self ): + return self._controlelementid + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._controlelementid = ifcidentifier(value) + else: + self._controlelementid = value + else: + self._controlelementid = value + return property(**locals()) + + @apply + def assignedtoflowelement(): + def fget( self ): + return self._assignedtoflowelement + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument assignedtoflowelement is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcelementcomponenttype # +#################### +class ifcelementcomponenttype(ifcelementtype): + '''Entity ifcelementcomponenttype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcfastenertype # +#################### +class ifcfastenertype(ifcelementcomponenttype): + '''Entity ifcfastenertype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementcomponenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifclamptype # +#################### +class ifclamptype(ifcflowterminaltype): + '''Entity ifclamptype definition. + + :param predefinedtype + :type predefinedtype:ifclamptypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifclamptypeenum): + self._predefinedtype = ifclamptypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcpredefineditem # +#################### +class ifcpredefineditem(BaseEntityClass): + '''Entity ifcpredefineditem definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifctrimmedcurve # +#################### +class ifctrimmedcurve(ifcboundedcurve): + '''Entity ifctrimmedcurve definition. + + :param basiscurve + :type basiscurve:ifccurve + + :param trim1 + :type trim1:SET(1,2,'ifctrimmingselect', scope = schema_scope) + + :param trim2 + :type trim2:SET(1,2,'ifctrimmingselect', scope = schema_scope) + + :param senseagreement + :type senseagreement:BOOLEAN + + :param masterrepresentation + :type masterrepresentation:ifctrimmingpreference + ''' + def __init__( self , basiscurve,trim1,trim2,senseagreement,masterrepresentation, ): + ifcboundedcurve.__init__(self , ) + self.basiscurve = basiscurve + self.trim1 = trim1 + self.trim2 = trim2 + self.senseagreement = senseagreement + self.masterrepresentation = masterrepresentation + + @apply + def basiscurve(): + def fget( self ): + return self._basiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._basiscurve = ifccurve(value) + else: + self._basiscurve = value + return property(**locals()) + + @apply + def trim1(): + def fget( self ): + return self._trim1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument trim1 is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'ifctrimmingselect', scope = schema_scope)): + self._trim1 = SET(value) + else: + self._trim1 = value + return property(**locals()) + + @apply + def trim2(): + def fget( self ): + return self._trim2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument trim2 is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'ifctrimmingselect', scope = schema_scope)): + self._trim2 = SET(value) + else: + self._trim2 = value + return property(**locals()) + + @apply + def senseagreement(): + def fget( self ): + return self._senseagreement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument senseagreement is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._senseagreement = BOOLEAN(value) + else: + self._senseagreement = value + return property(**locals()) + + @apply + def masterrepresentation(): + def fget( self ): + return self._masterrepresentation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument masterrepresentation is mantatory and can not be set to None') + if not check_type(value,ifctrimmingpreference): + self._masterrepresentation = ifctrimmingpreference(value) + else: + self._masterrepresentation = value + return property(**locals()) + def wr41(self): + eval_wr41_wr = ((HIINDEX(self.trim1) == 1) or (TYPEOF(self.trim1[1]) != TYPEOF(self.trim1[2]))) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + def wr42(self): + eval_wr42_wr = ((HIINDEX(self.trim2) == 1) or (TYPEOF(self.trim2[1]) != TYPEOF(self.trim2[2]))) + if not eval_wr42_wr: + raise AssertionError('Rule wr42 violated') + else: + return eval_wr42_wr + + def wr43(self): + eval_wr43_wr = ( not ('IFC2X3.IFCBOUNDEDCURVE' == TYPEOF(self.basiscurve))) + if not eval_wr43_wr: + raise AssertionError('Rule wr43 violated') + else: + return eval_wr43_wr + + +#################### + # ENTITY ifcboundarynodecondition # +#################### +class ifcboundarynodecondition(ifcboundarycondition): + '''Entity ifcboundarynodecondition definition. + + :param linearstiffnessx + :type linearstiffnessx:ifclinearstiffnessmeasure + + :param linearstiffnessy + :type linearstiffnessy:ifclinearstiffnessmeasure + + :param linearstiffnessz + :type linearstiffnessz:ifclinearstiffnessmeasure + + :param rotationalstiffnessx + :type rotationalstiffnessx:ifcrotationalstiffnessmeasure + + :param rotationalstiffnessy + :type rotationalstiffnessy:ifcrotationalstiffnessmeasure + + :param rotationalstiffnessz + :type rotationalstiffnessz:ifcrotationalstiffnessmeasure + ''' + def __init__( self , inherited0__name , linearstiffnessx,linearstiffnessy,linearstiffnessz,rotationalstiffnessx,rotationalstiffnessy,rotationalstiffnessz, ): + ifcboundarycondition.__init__(self , inherited0__name , ) + self.linearstiffnessx = linearstiffnessx + self.linearstiffnessy = linearstiffnessy + self.linearstiffnessz = linearstiffnessz + self.rotationalstiffnessx = rotationalstiffnessx + self.rotationalstiffnessy = rotationalstiffnessy + self.rotationalstiffnessz = rotationalstiffnessz + + @apply + def linearstiffnessx(): + def fget( self ): + return self._linearstiffnessx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearstiffnessmeasure): + self._linearstiffnessx = ifclinearstiffnessmeasure(value) + else: + self._linearstiffnessx = value + else: + self._linearstiffnessx = value + return property(**locals()) + + @apply + def linearstiffnessy(): + def fget( self ): + return self._linearstiffnessy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearstiffnessmeasure): + self._linearstiffnessy = ifclinearstiffnessmeasure(value) + else: + self._linearstiffnessy = value + else: + self._linearstiffnessy = value + return property(**locals()) + + @apply + def linearstiffnessz(): + def fget( self ): + return self._linearstiffnessz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearstiffnessmeasure): + self._linearstiffnessz = ifclinearstiffnessmeasure(value) + else: + self._linearstiffnessz = value + else: + self._linearstiffnessz = value + return property(**locals()) + + @apply + def rotationalstiffnessx(): + def fget( self ): + return self._rotationalstiffnessx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrotationalstiffnessmeasure): + self._rotationalstiffnessx = ifcrotationalstiffnessmeasure(value) + else: + self._rotationalstiffnessx = value + else: + self._rotationalstiffnessx = value + return property(**locals()) + + @apply + def rotationalstiffnessy(): + def fget( self ): + return self._rotationalstiffnessy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrotationalstiffnessmeasure): + self._rotationalstiffnessy = ifcrotationalstiffnessmeasure(value) + else: + self._rotationalstiffnessy = value + else: + self._rotationalstiffnessy = value + return property(**locals()) + + @apply + def rotationalstiffnessz(): + def fget( self ): + return self._rotationalstiffnessz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrotationalstiffnessmeasure): + self._rotationalstiffnessz = ifcrotationalstiffnessmeasure(value) + else: + self._rotationalstiffnessz = value + else: + self._rotationalstiffnessz = value + return property(**locals()) + +#################### + # ENTITY ifcboundarynodeconditionwarping # +#################### +class ifcboundarynodeconditionwarping(ifcboundarynodecondition): + '''Entity ifcboundarynodeconditionwarping definition. + + :param warpingstiffness + :type warpingstiffness:ifcwarpingmomentmeasure + ''' + def __init__( self , inherited0__name , inherited1__linearstiffnessx , inherited2__linearstiffnessy , inherited3__linearstiffnessz , inherited4__rotationalstiffnessx , inherited5__rotationalstiffnessy , inherited6__rotationalstiffnessz , warpingstiffness, ): + ifcboundarynodecondition.__init__(self , inherited0__name , inherited1__linearstiffnessx , inherited2__linearstiffnessy , inherited3__linearstiffnessz , inherited4__rotationalstiffnessx , inherited5__rotationalstiffnessy , inherited6__rotationalstiffnessz , ) + self.warpingstiffness = warpingstiffness + + @apply + def warpingstiffness(): + def fget( self ): + return self._warpingstiffness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcwarpingmomentmeasure): + self._warpingstiffness = ifcwarpingmomentmeasure(value) + else: + self._warpingstiffness = value + else: + self._warpingstiffness = value + return property(**locals()) + +#################### + # ENTITY ifctopologicalrepresentationitem # +#################### +class ifctopologicalrepresentationitem(ifcrepresentationitem): + '''Entity ifctopologicalrepresentationitem definition. + ''' + def __init__( self , ): + ifcrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifcedge # +#################### +class ifcedge(ifctopologicalrepresentationitem): + '''Entity ifcedge definition. + + :param edgestart + :type edgestart:ifcvertex + + :param edgeend + :type edgeend:ifcvertex + ''' + def __init__( self , edgestart,edgeend, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.edgestart = edgestart + self.edgeend = edgeend + + @apply + def edgestart(): + def fget( self ): + return self._edgestart + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgestart is mantatory and can not be set to None') + if not check_type(value,ifcvertex): + self._edgestart = ifcvertex(value) + else: + self._edgestart = value + return property(**locals()) + + @apply + def edgeend(): + def fget( self ): + return self._edgeend + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgeend is mantatory and can not be set to None') + if not check_type(value,ifcvertex): + self._edgeend = ifcvertex(value) + else: + self._edgeend = value + return property(**locals()) + +#################### + # ENTITY ifcsubedge # +#################### +class ifcsubedge(ifcedge): + '''Entity ifcsubedge definition. + + :param parentedge + :type parentedge:ifcedge + ''' + def __init__( self , inherited0__edgestart , inherited1__edgeend , parentedge, ): + ifcedge.__init__(self , inherited0__edgestart , inherited1__edgeend , ) + self.parentedge = parentedge + + @apply + def parentedge(): + def fget( self ): + return self._parentedge + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parentedge is mantatory and can not be set to None') + if not check_type(value,ifcedge): + self._parentedge = ifcedge(value) + else: + self._parentedge = value + return property(**locals()) + +#################### + # ENTITY ifcairtoairheatrecoverytype # +#################### +class ifcairtoairheatrecoverytype(ifcenergyconversiondevicetype): + '''Entity ifcairtoairheatrecoverytype definition. + + :param predefinedtype + :type predefinedtype:ifcairtoairheatrecoverytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcairtoairheatrecoverytypeenum): + self._predefinedtype = ifcairtoairheatrecoverytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcairtoairheatrecoverytypeenum.self.userdefined) or ((self.predefinedtype == ifcairtoairheatrecoverytypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccartesiantransformationoperator # +#################### +class ifccartesiantransformationoperator(ifcgeometricrepresentationitem): + '''Entity ifccartesiantransformationoperator definition. + + :param axis1 + :type axis1:ifcdirection + + :param axis2 + :type axis2:ifcdirection + + :param localorigin + :type localorigin:ifccartesianpoint + + :param scale + :type scale:REAL + + :param scl + :type scl:REAL + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , axis1,axis2,localorigin,scale, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.axis1 = axis1 + self.axis2 = axis2 + self.localorigin = localorigin + self.scale = scale + + @apply + def axis1(): + def fget( self ): + return self._axis1 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis1 = ifcdirection(value) + else: + self._axis1 = value + else: + self._axis1 = value + return property(**locals()) + + @apply + def axis2(): + def fget( self ): + return self._axis2 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis2 = ifcdirection(value) + else: + self._axis2 = value + else: + self._axis2 = value + return property(**locals()) + + @apply + def localorigin(): + def fget( self ): + return self._localorigin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument localorigin is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._localorigin = ifccartesianpoint(value) + else: + self._localorigin = value + return property(**locals()) + + @apply + def scale(): + def fget( self ): + return self._scale + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._scale = REAL(value) + else: + self._scale = value + else: + self._scale = value + return property(**locals()) + + @apply + def scl(): + def fget( self ): + attribute_eval = NVL(self.scale,1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scl is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.localorigin.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.scl > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccartesiantransformationoperator3d # +#################### +class ifccartesiantransformationoperator3d(ifccartesiantransformationoperator): + '''Entity ifccartesiantransformationoperator3d definition. + + :param axis3 + :type axis3:ifcdirection + + :param u + :type u:LIST(3,3,'ifcdirection', scope = schema_scope) + ''' + def __init__( self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , axis3, ): + ifccartesiantransformationoperator.__init__(self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , ) + self.axis3 = axis3 + + @apply + def axis3(): + def fget( self ): + return self._axis3 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis3 = ifcdirection(value) + else: + self._axis3 = value + else: + self._axis3 = value + return property(**locals()) + + @apply + def u(): + def fget( self ): + attribute_eval = ifcbaseaxis(3,self.self.ifccartesiantransformationoperator.self.axis1,self.self.ifccartesiantransformationoperator.self.axis2,self.axis3) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument u is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.ifccartesiantransformationoperator.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not EXISTS(self.self.ifccartesiantransformationoperator.self.axis1)) or (self.self.ifccartesiantransformationoperator.self.axis1.self.dim == 3)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not EXISTS(self.self.ifccartesiantransformationoperator.self.axis2)) or (self.self.ifccartesiantransformationoperator.self.axis2.self.dim == 3)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (( not EXISTS(self.axis3)) or (self.axis3.self.dim == 3)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY ifcconnectiongeometry # +#################### +class ifcconnectiongeometry(BaseEntityClass): + '''Entity ifcconnectiongeometry definition. + ''' + # This class does not define any attribute. + pass + +#################### + # ENTITY ifcplanarextent # +#################### +class ifcplanarextent(ifcgeometricrepresentationitem): + '''Entity ifcplanarextent definition. + + :param sizeinx + :type sizeinx:ifclengthmeasure + + :param sizeiny + :type sizeiny:ifclengthmeasure + ''' + def __init__( self , sizeinx,sizeiny, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.sizeinx = sizeinx + self.sizeiny = sizeiny + + @apply + def sizeinx(): + def fget( self ): + return self._sizeinx + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sizeinx is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._sizeinx = ifclengthmeasure(value) + else: + self._sizeinx = value + return property(**locals()) + + @apply + def sizeiny(): + def fget( self ): + return self._sizeiny + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sizeiny is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._sizeiny = ifclengthmeasure(value) + else: + self._sizeiny = value + return property(**locals()) + +#################### + # ENTITY ifcplanarbox # +#################### +class ifcplanarbox(ifcplanarextent): + '''Entity ifcplanarbox definition. + + :param placement + :type placement:ifcaxis2placement + ''' + def __init__( self , inherited0__sizeinx , inherited1__sizeiny , placement, ): + ifcplanarextent.__init__(self , inherited0__sizeinx , inherited1__sizeiny , ) + self.placement = placement + + @apply + def placement(): + def fget( self ): + return self._placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placement is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._placement = ifcaxis2placement(value) + else: + self._placement = value + return property(**locals()) + +#################### + # ENTITY ifcfooting # +#################### +class ifcfooting(ifcbuildingelement): + '''Entity ifcfooting definition. + + :param predefinedtype + :type predefinedtype:ifcfootingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcfootingtypeenum): + self._predefinedtype = ifcfootingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcfootingtypeenum.self.userdefined) or ((self.predefinedtype == ifcfootingtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcpredefinedcolour # +#################### +class ifcpredefinedcolour(ifcpredefineditem): + '''Entity ifcpredefinedcolour definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefineditem.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcrelaggregates # +#################### +class ifcrelaggregates(ifcreldecomposes): + '''Entity ifcrelaggregates definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingobject , inherited5__relatedobjects , ): + ifcreldecomposes.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingobject , inherited5__relatedobjects , ) + +#################### + # ENTITY ifcrelconnectsstructuralelement # +#################### +class ifcrelconnectsstructuralelement(ifcrelconnects): + '''Entity ifcrelconnectsstructuralelement definition. + + :param relatingelement + :type relatingelement:ifcelement + + :param relatedstructuralmember + :type relatedstructuralmember:ifcstructuralmember + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingelement,relatedstructuralmember, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingelement = relatingelement + self.relatedstructuralmember = relatedstructuralmember + + @apply + def relatingelement(): + def fget( self ): + return self._relatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingelement = ifcelement(value) + else: + self._relatingelement = value + return property(**locals()) + + @apply + def relatedstructuralmember(): + def fget( self ): + return self._relatedstructuralmember + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedstructuralmember is mantatory and can not be set to None') + if not check_type(value,ifcstructuralmember): + self._relatedstructuralmember = ifcstructuralmember(value) + else: + self._relatedstructuralmember = value + return property(**locals()) + +#################### + # ENTITY ifctextstyle # +#################### +class ifctextstyle(ifcpresentationstyle): + '''Entity ifctextstyle definition. + + :param textcharacterappearance + :type textcharacterappearance:ifccharacterstyleselect + + :param textstyle + :type textstyle:ifctextstyleselect + + :param textfontstyle + :type textfontstyle:ifctextfontselect + ''' + def __init__( self , inherited0__name , textcharacterappearance,textstyle,textfontstyle, ): + ifcpresentationstyle.__init__(self , inherited0__name , ) + self.textcharacterappearance = textcharacterappearance + self.textstyle = textstyle + self.textfontstyle = textfontstyle + + @apply + def textcharacterappearance(): + def fget( self ): + return self._textcharacterappearance + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccharacterstyleselect): + self._textcharacterappearance = ifccharacterstyleselect(value) + else: + self._textcharacterappearance = value + else: + self._textcharacterappearance = value + return property(**locals()) + + @apply + def textstyle(): + def fget( self ): + return self._textstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctextstyleselect): + self._textstyle = ifctextstyleselect(value) + else: + self._textstyle = value + else: + self._textstyle = value + return property(**locals()) + + @apply + def textfontstyle(): + def fget( self ): + return self._textfontstyle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument textfontstyle is mantatory and can not be set to None') + if not check_type(value,ifctextfontselect): + self._textfontstyle = ifctextfontselect(value) + else: + self._textfontstyle = value + return property(**locals()) + +#################### + # ENTITY ifcwall # +#################### +class ifcwall(ifcbuildingelement): + '''Entity ifcwall definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcdistributioncontrolelementtype # +#################### +class ifcdistributioncontrolelementtype(ifcdistributionelementtype): + '''Entity ifcdistributioncontrolelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcactuatortype # +#################### +class ifcactuatortype(ifcdistributioncontrolelementtype): + '''Entity ifcactuatortype definition. + + :param predefinedtype + :type predefinedtype:ifcactuatortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcactuatortypeenum): + self._predefinedtype = ifcactuatortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcfailureconnectioncondition # +#################### +class ifcfailureconnectioncondition(ifcstructuralconnectioncondition): + '''Entity ifcfailureconnectioncondition definition. + + :param tensionfailurex + :type tensionfailurex:ifcforcemeasure + + :param tensionfailurey + :type tensionfailurey:ifcforcemeasure + + :param tensionfailurez + :type tensionfailurez:ifcforcemeasure + + :param compressionfailurex + :type compressionfailurex:ifcforcemeasure + + :param compressionfailurey + :type compressionfailurey:ifcforcemeasure + + :param compressionfailurez + :type compressionfailurez:ifcforcemeasure + ''' + def __init__( self , inherited0__name , tensionfailurex,tensionfailurey,tensionfailurez,compressionfailurex,compressionfailurey,compressionfailurez, ): + ifcstructuralconnectioncondition.__init__(self , inherited0__name , ) + self.tensionfailurex = tensionfailurex + self.tensionfailurey = tensionfailurey + self.tensionfailurez = tensionfailurez + self.compressionfailurex = compressionfailurex + self.compressionfailurey = compressionfailurey + self.compressionfailurez = compressionfailurez + + @apply + def tensionfailurex(): + def fget( self ): + return self._tensionfailurex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._tensionfailurex = ifcforcemeasure(value) + else: + self._tensionfailurex = value + else: + self._tensionfailurex = value + return property(**locals()) + + @apply + def tensionfailurey(): + def fget( self ): + return self._tensionfailurey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._tensionfailurey = ifcforcemeasure(value) + else: + self._tensionfailurey = value + else: + self._tensionfailurey = value + return property(**locals()) + + @apply + def tensionfailurez(): + def fget( self ): + return self._tensionfailurez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._tensionfailurez = ifcforcemeasure(value) + else: + self._tensionfailurez = value + else: + self._tensionfailurez = value + return property(**locals()) + + @apply + def compressionfailurex(): + def fget( self ): + return self._compressionfailurex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._compressionfailurex = ifcforcemeasure(value) + else: + self._compressionfailurex = value + else: + self._compressionfailurex = value + return property(**locals()) + + @apply + def compressionfailurey(): + def fget( self ): + return self._compressionfailurey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._compressionfailurey = ifcforcemeasure(value) + else: + self._compressionfailurey = value + else: + self._compressionfailurey = value + return property(**locals()) + + @apply + def compressionfailurez(): + def fget( self ): + return self._compressionfailurez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._compressionfailurez = ifcforcemeasure(value) + else: + self._compressionfailurez = value + else: + self._compressionfailurez = value + return property(**locals()) + +#################### + # ENTITY ifcsymbolstyle # +#################### +class ifcsymbolstyle(ifcpresentationstyle): + '''Entity ifcsymbolstyle definition. + + :param styleofsymbol + :type styleofsymbol:ifcsymbolstyleselect + ''' + def __init__( self , inherited0__name , styleofsymbol, ): + ifcpresentationstyle.__init__(self , inherited0__name , ) + self.styleofsymbol = styleofsymbol + + @apply + def styleofsymbol(): + def fget( self ): + return self._styleofsymbol + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styleofsymbol is mantatory and can not be set to None') + if not check_type(value,ifcsymbolstyleselect): + self._styleofsymbol = ifcsymbolstyleselect(value) + else: + self._styleofsymbol = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralsurfaceconnection # +#################### +class ifcstructuralsurfaceconnection(ifcstructuralconnection): + '''Entity ifcstructuralsurfaceconnection definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ): + ifcstructuralconnection.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ) + +#################### + # ENTITY ifccomplexproperty # +#################### +class ifccomplexproperty(ifcproperty): + '''Entity ifccomplexproperty definition. + + :param usagename + :type usagename:ifcidentifier + + :param hasproperties + :type hasproperties:SET(1,None,'ifcproperty', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , usagename,hasproperties, ): + ifcproperty.__init__(self , inherited0__name , inherited1__description , ) + self.usagename = usagename + self.hasproperties = hasproperties + + @apply + def usagename(): + def fget( self ): + return self._usagename + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument usagename is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._usagename = ifcidentifier(value) + else: + self._usagename = value + return property(**locals()) + + @apply + def hasproperties(): + def fget( self ): + return self._hasproperties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hasproperties is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproperty', scope = schema_scope)): + self._hasproperties = SET(value) + else: + self._hasproperties = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = ifcuniquepropertyname(self.hasproperties) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcpredefinedsymbol # +#################### +class ifcpredefinedsymbol(ifcpredefineditem): + '''Entity ifcpredefinedsymbol definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefineditem.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcpredefineddimensionsymbol # +#################### +class ifcpredefineddimensionsymbol(ifcpredefinedsymbol): + '''Entity ifcpredefineddimensionsymbol definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefinedsymbol.__init__(self , inherited0__name , ) + def wr31(self): + eval_wr31_wr = (self.self.ifcpredefineditem.self.name == ['arc length','conical taper','counterbore','countersink','depth','diameter','plus minus','radius','slope','spherical diameter','spherical radius','square']) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcboundedsurface # +#################### +class ifcboundedsurface(ifcsurface): + '''Entity ifcboundedsurface definition. + ''' + def __init__( self , ): + ifcsurface.__init__(self , ) + +#################### + # ENTITY ifccurveboundedplane # +#################### +class ifccurveboundedplane(ifcboundedsurface): + '''Entity ifccurveboundedplane definition. + + :param basissurface + :type basissurface:ifcplane + + :param outerboundary + :type outerboundary:ifccurve + + :param innerboundaries + :type innerboundaries:SET(0,None,'ifccurve', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , basissurface,outerboundary,innerboundaries, ): + ifcboundedsurface.__init__(self , ) + self.basissurface = basissurface + self.outerboundary = outerboundary + self.innerboundaries = innerboundaries + + @apply + def basissurface(): + def fget( self ): + return self._basissurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basissurface is mantatory and can not be set to None') + if not check_type(value,ifcplane): + self._basissurface = ifcplane(value) + else: + self._basissurface = value + return property(**locals()) + + @apply + def outerboundary(): + def fget( self ): + return self._outerboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument outerboundary is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._outerboundary = ifccurve(value) + else: + self._outerboundary = value + return property(**locals()) + + @apply + def innerboundaries(): + def fget( self ): + return self._innerboundaries + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument innerboundaries is mantatory and can not be set to None') + if not check_type(value,SET(0,None,'ifccurve', scope = schema_scope)): + self._innerboundaries = SET(value) + else: + self._innerboundaries = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.basissurface.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcface # +#################### +class ifcface(ifctopologicalrepresentationitem): + '''Entity ifcface definition. + + :param bounds + :type bounds:SET(1,None,'ifcfacebound', scope = schema_scope) + ''' + def __init__( self , bounds, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.bounds = bounds + + @apply + def bounds(): + def fget( self ): + return self._bounds + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bounds is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcfacebound', scope = schema_scope)): + self._bounds = SET(value) + else: + self._bounds = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcfacesurface # +#################### +class ifcfacesurface(ifcface): + '''Entity ifcfacesurface definition. + + :param facesurface + :type facesurface:ifcsurface + + :param samesense + :type samesense:BOOLEAN + ''' + def __init__( self , inherited0__bounds , facesurface,samesense, ): + ifcface.__init__(self , inherited0__bounds , ) + self.facesurface = facesurface + self.samesense = samesense + + @apply + def facesurface(): + def fget( self ): + return self._facesurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument facesurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._facesurface = ifcsurface(value) + else: + self._facesurface = value + return property(**locals()) + + @apply + def samesense(): + def fget( self ): + return self._samesense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument samesense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._samesense = BOOLEAN(value) + else: + self._samesense = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralanalysismodel # +#################### +class ifcstructuralanalysismodel(ifcsystem): + '''Entity ifcstructuralanalysismodel definition. + + :param predefinedtype + :type predefinedtype:ifcanalysismodeltypeenum + + :param orientationof2dplane + :type orientationof2dplane:ifcaxis2placement3d + + :param loadedby + :type loadedby:SET(1,None,'ifcstructuralloadgroup', scope = schema_scope) + + :param hasresults + :type hasresults:SET(1,None,'ifcstructuralresultgroup', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , predefinedtype,orientationof2dplane,loadedby,hasresults, ): + ifcsystem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.predefinedtype = predefinedtype + self.orientationof2dplane = orientationof2dplane + self.loadedby = loadedby + self.hasresults = hasresults + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcanalysismodeltypeenum): + self._predefinedtype = ifcanalysismodeltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def orientationof2dplane(): + def fget( self ): + return self._orientationof2dplane + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaxis2placement3d): + self._orientationof2dplane = ifcaxis2placement3d(value) + else: + self._orientationof2dplane = value + else: + self._orientationof2dplane = value + return property(**locals()) + + @apply + def loadedby(): + def fget( self ): + return self._loadedby + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcstructuralloadgroup', scope = schema_scope)): + self._loadedby = SET(value) + else: + self._loadedby = value + else: + self._loadedby = value + return property(**locals()) + + @apply + def hasresults(): + def fget( self ): + return self._hasresults + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcstructuralresultgroup', scope = schema_scope)): + self._hasresults = SET(value) + else: + self._hasresults = value + else: + self._hasresults = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralloadsingleforce # +#################### +class ifcstructuralloadsingleforce(ifcstructuralloadstatic): + '''Entity ifcstructuralloadsingleforce definition. + + :param forcex + :type forcex:ifcforcemeasure + + :param forcey + :type forcey:ifcforcemeasure + + :param forcez + :type forcez:ifcforcemeasure + + :param momentx + :type momentx:ifctorquemeasure + + :param momenty + :type momenty:ifctorquemeasure + + :param momentz + :type momentz:ifctorquemeasure + ''' + def __init__( self , inherited0__name , forcex,forcey,forcez,momentx,momenty,momentz, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.forcex = forcex + self.forcey = forcey + self.forcez = forcez + self.momentx = momentx + self.momenty = momenty + self.momentz = momentz + + @apply + def forcex(): + def fget( self ): + return self._forcex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._forcex = ifcforcemeasure(value) + else: + self._forcex = value + else: + self._forcex = value + return property(**locals()) + + @apply + def forcey(): + def fget( self ): + return self._forcey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._forcey = ifcforcemeasure(value) + else: + self._forcey = value + else: + self._forcey = value + return property(**locals()) + + @apply + def forcez(): + def fget( self ): + return self._forcez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._forcez = ifcforcemeasure(value) + else: + self._forcez = value + else: + self._forcez = value + return property(**locals()) + + @apply + def momentx(): + def fget( self ): + return self._momentx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctorquemeasure): + self._momentx = ifctorquemeasure(value) + else: + self._momentx = value + else: + self._momentx = value + return property(**locals()) + + @apply + def momenty(): + def fget( self ): + return self._momenty + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctorquemeasure): + self._momenty = ifctorquemeasure(value) + else: + self._momenty = value + else: + self._momenty = value + return property(**locals()) + + @apply + def momentz(): + def fget( self ): + return self._momentz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctorquemeasure): + self._momentz = ifctorquemeasure(value) + else: + self._momentz = value + else: + self._momentz = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralloadsingleforcewarping # +#################### +class ifcstructuralloadsingleforcewarping(ifcstructuralloadsingleforce): + '''Entity ifcstructuralloadsingleforcewarping definition. + + :param warpingmoment + :type warpingmoment:ifcwarpingmomentmeasure + ''' + def __init__( self , inherited0__name , inherited1__forcex , inherited2__forcey , inherited3__forcez , inherited4__momentx , inherited5__momenty , inherited6__momentz , warpingmoment, ): + ifcstructuralloadsingleforce.__init__(self , inherited0__name , inherited1__forcex , inherited2__forcey , inherited3__forcez , inherited4__momentx , inherited5__momenty , inherited6__momentz , ) + self.warpingmoment = warpingmoment + + @apply + def warpingmoment(): + def fget( self ): + return self._warpingmoment + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcwarpingmomentmeasure): + self._warpingmoment = ifcwarpingmomentmeasure(value) + else: + self._warpingmoment = value + else: + self._warpingmoment = value + return property(**locals()) + +#################### + # ENTITY ifcaxis2placement3d # +#################### +class ifcaxis2placement3d(ifcplacement): + '''Entity ifcaxis2placement3d definition. + + :param axis + :type axis:ifcdirection + + :param refdirection + :type refdirection:ifcdirection + + :param p + :type p:LIST(3,3,'ifcdirection', scope = schema_scope) + ''' + def __init__( self , inherited0__location , axis,refdirection, ): + ifcplacement.__init__(self , inherited0__location , ) + self.axis = axis + self.refdirection = refdirection + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis = ifcdirection(value) + else: + self._axis = value + else: + self._axis = value + return property(**locals()) + + @apply + def refdirection(): + def fget( self ): + return self._refdirection + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._refdirection = ifcdirection(value) + else: + self._refdirection = value + else: + self._refdirection = value + return property(**locals()) + + @apply + def p(): + def fget( self ): + attribute_eval = ifcbuildaxes(self.axis,self.refdirection) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument p is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.ifcplacement.self.location.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not EXISTS(self.axis)) or (self.axis.self.dim == 3)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not EXISTS(self.refdirection)) or (self.refdirection.self.dim == 3)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((( not EXISTS(self.axis)) or ( not EXISTS(self.refdirection))) or (ifccrossproduct(self.axis,self.refdirection).self.magnitude > 0)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + def wr5(self): + eval_wr5_wr = ( not (EXISTS(self.axis) XOR EXISTS(self.refdirection))) + if not eval_wr5_wr: + raise AssertionError('Rule wr5 violated') + else: + return eval_wr5_wr + + +#################### + # ENTITY ifchalfspacesolid # +#################### +class ifchalfspacesolid(ifcgeometricrepresentationitem): + '''Entity ifchalfspacesolid definition. + + :param basesurface + :type basesurface:ifcsurface + + :param agreementflag + :type agreementflag:BOOLEAN + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , basesurface,agreementflag, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.basesurface = basesurface + self.agreementflag = agreementflag + + @apply + def basesurface(): + def fget( self ): + return self._basesurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basesurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._basesurface = ifcsurface(value) + else: + self._basesurface = value + return property(**locals()) + + @apply + def agreementflag(): + def fget( self ): + return self._agreementflag + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument agreementflag is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._agreementflag = BOOLEAN(value) + else: + self._agreementflag = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcboxedhalfspace # +#################### +class ifcboxedhalfspace(ifchalfspacesolid): + '''Entity ifcboxedhalfspace definition. + + :param enclosure + :type enclosure:ifcboundingbox + ''' + def __init__( self , inherited0__basesurface , inherited1__agreementflag , enclosure, ): + ifchalfspacesolid.__init__(self , inherited0__basesurface , inherited1__agreementflag , ) + self.enclosure = enclosure + + @apply + def enclosure(): + def fget( self ): + return self._enclosure + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument enclosure is mantatory and can not be set to None') + if not check_type(value,ifcboundingbox): + self._enclosure = ifcboundingbox(value) + else: + self._enclosure = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('IFC2X3.IFCCURVEBOUNDEDPLANE' == TYPEOF(self.self.ifchalfspacesolid.self.basesurface))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccompositecurve # +#################### +class ifccompositecurve(ifcboundedcurve): + '''Entity ifccompositecurve definition. + + :param segments + :type segments:LIST(1,None,'ifccompositecurvesegment', scope = schema_scope) + + :param selfintersect + :type selfintersect:LOGICAL + + :param nsegments + :type nsegments:INTEGER + + :param closedcurve + :type closedcurve:LOGICAL + ''' + def __init__( self , segments,selfintersect, ): + ifcboundedcurve.__init__(self , ) + self.segments = segments + self.selfintersect = selfintersect + + @apply + def segments(): + def fget( self ): + return self._segments + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument segments is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifccompositecurvesegment', scope = schema_scope)): + self._segments = LIST(value) + else: + self._segments = value + return property(**locals()) + + @apply + def selfintersect(): + def fget( self ): + return self._selfintersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument selfintersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._selfintersect = LOGICAL(value) + else: + self._selfintersect = value + return property(**locals()) + + @apply + def nsegments(): + def fget( self ): + attribute_eval = SIZEOF(self.segments) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument nsegments is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def closedcurve(): + def fget( self ): + attribute_eval = (self.segments[self.nsegments].self.transition != discontinuous) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument closedcurve is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr41(self): + eval_wr41_wr = ((( not self.closedcurve) and (SIZEOF(None) == 1)) or (self.closedcurve and (SIZEOF(None) == 0))) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + def wr42(self): + eval_wr42_wr = (SIZEOF(None) == 0) + if not eval_wr42_wr: + raise AssertionError('Rule wr42 violated') + else: + return eval_wr42_wr + + +#################### + # ENTITY ifcroof # +#################### +class ifcroof(ifcbuildingelement): + '''Entity ifcroof definition. + + :param shapetype + :type shapetype:ifcrooftypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , shapetype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.shapetype = shapetype + + @apply + def shapetype(): + def fget( self ): + return self._shapetype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument shapetype is mantatory and can not be set to None') + if not check_type(value,ifcrooftypeenum): + self._shapetype = ifcrooftypeenum(value) + else: + self._shapetype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 0) or ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 1) and ( not EXISTS(self.self.ifcproduct.self.representation)))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcstructuralloadsingledisplacementdistortion # +#################### +class ifcstructuralloadsingledisplacementdistortion(ifcstructuralloadsingledisplacement): + '''Entity ifcstructuralloadsingledisplacementdistortion definition. + + :param distortion + :type distortion:ifccurvaturemeasure + ''' + def __init__( self , inherited0__name , inherited1__displacementx , inherited2__displacementy , inherited3__displacementz , inherited4__rotationaldisplacementrx , inherited5__rotationaldisplacementry , inherited6__rotationaldisplacementrz , distortion, ): + ifcstructuralloadsingledisplacement.__init__(self , inherited0__name , inherited1__displacementx , inherited2__displacementy , inherited3__displacementz , inherited4__rotationaldisplacementrx , inherited5__rotationaldisplacementry , inherited6__rotationaldisplacementrz , ) + self.distortion = distortion + + @apply + def distortion(): + def fget( self ): + return self._distortion + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccurvaturemeasure): + self._distortion = ifccurvaturemeasure(value) + else: + self._distortion = value + else: + self._distortion = value + return property(**locals()) + +#################### + # ENTITY ifcrepresentation # +#################### +class ifcrepresentation(BaseEntityClass): + '''Entity ifcrepresentation definition. + + :param contextofitems + :type contextofitems:ifcrepresentationcontext + + :param representationidentifier + :type representationidentifier:ifclabel + + :param representationtype + :type representationtype:ifclabel + + :param items + :type items:SET(1,None,'ifcrepresentationitem', scope = schema_scope) + + :param representationmap + :type representationmap:SET(0,1,'ifcrepresentationmap', scope = schema_scope) + + :param layerassignments + :type layerassignments:SET(0,None,'ifcpresentationlayerassignment', scope = schema_scope) + + :param ofproductrepresentation + :type ofproductrepresentation:SET(0,1,'ifcproductrepresentation', scope = schema_scope) + ''' + def __init__( self , contextofitems,representationidentifier,representationtype,items, ): + self.contextofitems = contextofitems + self.representationidentifier = representationidentifier + self.representationtype = representationtype + self.items = items + + @apply + def contextofitems(): + def fget( self ): + return self._contextofitems + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument contextofitems is mantatory and can not be set to None') + if not check_type(value,ifcrepresentationcontext): + self._contextofitems = ifcrepresentationcontext(value) + else: + self._contextofitems = value + return property(**locals()) + + @apply + def representationidentifier(): + def fget( self ): + return self._representationidentifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._representationidentifier = ifclabel(value) + else: + self._representationidentifier = value + else: + self._representationidentifier = value + return property(**locals()) + + @apply + def representationtype(): + def fget( self ): + return self._representationtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._representationtype = ifclabel(value) + else: + self._representationtype = value + else: + self._representationtype = value + return property(**locals()) + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcrepresentationitem', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + + @apply + def representationmap(): + def fget( self ): + return self._representationmap + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument representationmap is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def layerassignments(): + def fget( self ): + return self._layerassignments + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument layerassignments is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ofproductrepresentation(): + def fget( self ): + return self._ofproductrepresentation + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ofproductrepresentation is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifccompositecurvesegment # +#################### +class ifccompositecurvesegment(ifcgeometricrepresentationitem): + '''Entity ifccompositecurvesegment definition. + + :param transition + :type transition:ifctransitioncode + + :param samesense + :type samesense:BOOLEAN + + :param parentcurve + :type parentcurve:ifccurve + + :param dim + :type dim:ifcdimensioncount + + :param usingcurves + :type usingcurves:SET(1,None,'ifccompositecurve', scope = schema_scope) + ''' + def __init__( self , transition,samesense,parentcurve, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.transition = transition + self.samesense = samesense + self.parentcurve = parentcurve + + @apply + def transition(): + def fget( self ): + return self._transition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transition is mantatory and can not be set to None') + if not check_type(value,ifctransitioncode): + self._transition = ifctransitioncode(value) + else: + self._transition = value + return property(**locals()) + + @apply + def samesense(): + def fget( self ): + return self._samesense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument samesense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._samesense = BOOLEAN(value) + else: + self._samesense = value + return property(**locals()) + + @apply + def parentcurve(): + def fget( self ): + return self._parentcurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parentcurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._parentcurve = ifccurve(value) + else: + self._parentcurve = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.parentcurve.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def usingcurves(): + def fget( self ): + return self._usingcurves + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument usingcurves is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ('IFC2X3.IFCBOUNDEDCURVE' == TYPEOF(self.parentcurve)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcclassificationitem # +#################### +class ifcclassificationitem(BaseEntityClass): + '''Entity ifcclassificationitem definition. + + :param notation + :type notation:ifcclassificationnotationfacet + + :param itemof + :type itemof:ifcclassification + + :param title + :type title:ifclabel + + :param isclassifieditemin + :type isclassifieditemin:SET(0,1,'ifcclassificationitemrelationship', scope = schema_scope) + + :param isclassifyingitemin + :type isclassifyingitemin:SET(0,1,'ifcclassificationitemrelationship', scope = schema_scope) + ''' + def __init__( self , notation,itemof,title, ): + self.notation = notation + self.itemof = itemof + self.title = title + + @apply + def notation(): + def fget( self ): + return self._notation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument notation is mantatory and can not be set to None') + if not check_type(value,ifcclassificationnotationfacet): + self._notation = ifcclassificationnotationfacet(value) + else: + self._notation = value + return property(**locals()) + + @apply + def itemof(): + def fget( self ): + return self._itemof + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcclassification): + self._itemof = ifcclassification(value) + else: + self._itemof = value + else: + self._itemof = value + return property(**locals()) + + @apply + def title(): + def fget( self ): + return self._title + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument title is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._title = ifclabel(value) + else: + self._title = value + return property(**locals()) + + @apply + def isclassifieditemin(): + def fget( self ): + return self._isclassifieditemin + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isclassifieditemin is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isclassifyingitemin(): + def fget( self ): + return self._isclassifyingitemin + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isclassifyingitemin is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcoffsetcurve2d # +#################### +class ifcoffsetcurve2d(ifccurve): + '''Entity ifcoffsetcurve2d definition. + + :param basiscurve + :type basiscurve:ifccurve + + :param distance + :type distance:ifclengthmeasure + + :param selfintersect + :type selfintersect:LOGICAL + ''' + def __init__( self , basiscurve,distance,selfintersect, ): + ifccurve.__init__(self , ) + self.basiscurve = basiscurve + self.distance = distance + self.selfintersect = selfintersect + + @apply + def basiscurve(): + def fget( self ): + return self._basiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._basiscurve = ifccurve(value) + else: + self._basiscurve = value + return property(**locals()) + + @apply + def distance(): + def fget( self ): + return self._distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distance is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._distance = ifclengthmeasure(value) + else: + self._distance = value + return property(**locals()) + + @apply + def selfintersect(): + def fget( self ): + return self._selfintersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument selfintersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._selfintersect = LOGICAL(value) + else: + self._selfintersect = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.basiscurve.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelassignstogroup # +#################### +class ifcrelassignstogroup(ifcrelassigns): + '''Entity ifcrelassignstogroup definition. + + :param relatinggroup + :type relatinggroup:ifcgroup + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatinggroup, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatinggroup = relatinggroup + + @apply + def relatinggroup(): + def fget( self ): + return self._relatinggroup + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatinggroup is mantatory and can not be set to None') + if not check_type(value,ifcgroup): + self._relatinggroup = ifcgroup(value) + else: + self._relatinggroup = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcequipmentelement # +#################### +class ifcequipmentelement(ifcelement): + '''Entity ifcequipmentelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcreinforcementdefinitionproperties # +#################### +class ifcreinforcementdefinitionproperties(ifcpropertysetdefinition): + '''Entity ifcreinforcementdefinitionproperties definition. + + :param definitiontype + :type definitiontype:ifclabel + + :param reinforcementsectiondefinitions + :type reinforcementsectiondefinitions:LIST(1,None,'ifcsectionreinforcementproperties', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , definitiontype,reinforcementsectiondefinitions, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.definitiontype = definitiontype + self.reinforcementsectiondefinitions = reinforcementsectiondefinitions + + @apply + def definitiontype(): + def fget( self ): + return self._definitiontype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._definitiontype = ifclabel(value) + else: + self._definitiontype = value + else: + self._definitiontype = value + return property(**locals()) + + @apply + def reinforcementsectiondefinitions(): + def fget( self ): + return self._reinforcementsectiondefinitions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reinforcementsectiondefinitions is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcsectionreinforcementproperties', scope = schema_scope)): + self._reinforcementsectiondefinitions = LIST(value) + else: + self._reinforcementsectiondefinitions = value + return property(**locals()) + +#################### + # ENTITY ifcrelassociatesclassification # +#################### +class ifcrelassociatesclassification(ifcrelassociates): + '''Entity ifcrelassociatesclassification definition. + + :param relatingclassification + :type relatingclassification:ifcclassificationnotationselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingclassification, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingclassification = relatingclassification + + @apply + def relatingclassification(): + def fget( self ): + return self._relatingclassification + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingclassification is mantatory and can not be set to None') + if not check_type(value,ifcclassificationnotationselect): + self._relatingclassification = ifcclassificationnotationselect(value) + else: + self._relatingclassification = value + return property(**locals()) + +#################### + # ENTITY ifcrelvoidselement # +#################### +class ifcrelvoidselement(ifcrelconnects): + '''Entity ifcrelvoidselement definition. + + :param relatingbuildingelement + :type relatingbuildingelement:ifcelement + + :param relatedopeningelement + :type relatedopeningelement:ifcfeatureelementsubtraction + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingbuildingelement,relatedopeningelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingbuildingelement = relatingbuildingelement + self.relatedopeningelement = relatedopeningelement + + @apply + def relatingbuildingelement(): + def fget( self ): + return self._relatingbuildingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingbuildingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingbuildingelement = ifcelement(value) + else: + self._relatingbuildingelement = value + return property(**locals()) + + @apply + def relatedopeningelement(): + def fget( self ): + return self._relatedopeningelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedopeningelement is mantatory and can not be set to None') + if not check_type(value,ifcfeatureelementsubtraction): + self._relatedopeningelement = ifcfeatureelementsubtraction(value) + else: + self._relatedopeningelement = value + return property(**locals()) + +#################### + # ENTITY ifcboundaryedgecondition # +#################### +class ifcboundaryedgecondition(ifcboundarycondition): + '''Entity ifcboundaryedgecondition definition. + + :param linearstiffnessbylengthx + :type linearstiffnessbylengthx:ifcmodulusoflinearsubgradereactionmeasure + + :param linearstiffnessbylengthy + :type linearstiffnessbylengthy:ifcmodulusoflinearsubgradereactionmeasure + + :param linearstiffnessbylengthz + :type linearstiffnessbylengthz:ifcmodulusoflinearsubgradereactionmeasure + + :param rotationalstiffnessbylengthx + :type rotationalstiffnessbylengthx:ifcmodulusofrotationalsubgradereactionmeasure + + :param rotationalstiffnessbylengthy + :type rotationalstiffnessbylengthy:ifcmodulusofrotationalsubgradereactionmeasure + + :param rotationalstiffnessbylengthz + :type rotationalstiffnessbylengthz:ifcmodulusofrotationalsubgradereactionmeasure + ''' + def __init__( self , inherited0__name , linearstiffnessbylengthx,linearstiffnessbylengthy,linearstiffnessbylengthz,rotationalstiffnessbylengthx,rotationalstiffnessbylengthy,rotationalstiffnessbylengthz, ): + ifcboundarycondition.__init__(self , inherited0__name , ) + self.linearstiffnessbylengthx = linearstiffnessbylengthx + self.linearstiffnessbylengthy = linearstiffnessbylengthy + self.linearstiffnessbylengthz = linearstiffnessbylengthz + self.rotationalstiffnessbylengthx = rotationalstiffnessbylengthx + self.rotationalstiffnessbylengthy = rotationalstiffnessbylengthy + self.rotationalstiffnessbylengthz = rotationalstiffnessbylengthz + + @apply + def linearstiffnessbylengthx(): + def fget( self ): + return self._linearstiffnessbylengthx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusoflinearsubgradereactionmeasure): + self._linearstiffnessbylengthx = ifcmodulusoflinearsubgradereactionmeasure(value) + else: + self._linearstiffnessbylengthx = value + else: + self._linearstiffnessbylengthx = value + return property(**locals()) + + @apply + def linearstiffnessbylengthy(): + def fget( self ): + return self._linearstiffnessbylengthy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusoflinearsubgradereactionmeasure): + self._linearstiffnessbylengthy = ifcmodulusoflinearsubgradereactionmeasure(value) + else: + self._linearstiffnessbylengthy = value + else: + self._linearstiffnessbylengthy = value + return property(**locals()) + + @apply + def linearstiffnessbylengthz(): + def fget( self ): + return self._linearstiffnessbylengthz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusoflinearsubgradereactionmeasure): + self._linearstiffnessbylengthz = ifcmodulusoflinearsubgradereactionmeasure(value) + else: + self._linearstiffnessbylengthz = value + else: + self._linearstiffnessbylengthz = value + return property(**locals()) + + @apply + def rotationalstiffnessbylengthx(): + def fget( self ): + return self._rotationalstiffnessbylengthx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofrotationalsubgradereactionmeasure): + self._rotationalstiffnessbylengthx = ifcmodulusofrotationalsubgradereactionmeasure(value) + else: + self._rotationalstiffnessbylengthx = value + else: + self._rotationalstiffnessbylengthx = value + return property(**locals()) + + @apply + def rotationalstiffnessbylengthy(): + def fget( self ): + return self._rotationalstiffnessbylengthy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofrotationalsubgradereactionmeasure): + self._rotationalstiffnessbylengthy = ifcmodulusofrotationalsubgradereactionmeasure(value) + else: + self._rotationalstiffnessbylengthy = value + else: + self._rotationalstiffnessbylengthy = value + return property(**locals()) + + @apply + def rotationalstiffnessbylengthz(): + def fget( self ): + return self._rotationalstiffnessbylengthz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofrotationalsubgradereactionmeasure): + self._rotationalstiffnessbylengthz = ifcmodulusofrotationalsubgradereactionmeasure(value) + else: + self._rotationalstiffnessbylengthz = value + else: + self._rotationalstiffnessbylengthz = value + return property(**locals()) + +#################### + # ENTITY ifcflowtreatmentdevicetype # +#################### +class ifcflowtreatmentdevicetype(ifcdistributionflowelementtype): + '''Entity ifcflowtreatmentdevicetype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcgeometricset # +#################### +class ifcgeometricset(ifcgeometricrepresentationitem): + '''Entity ifcgeometricset definition. + + :param elements + :type elements:SET(1,None,'ifcgeometricsetselect', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , elements, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.elements = elements + + @apply + def elements(): + def fget( self ): + return self._elements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument elements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcgeometricsetselect', scope = schema_scope)): + self._elements = SET(value) + else: + self._elements = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.elements[1].self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcmaterialclassificationrelationship # +#################### +class ifcmaterialclassificationrelationship(BaseEntityClass): + '''Entity ifcmaterialclassificationrelationship definition. + + :param materialclassifications + :type materialclassifications:SET(1,None,'ifcclassificationnotationselect', scope = schema_scope) + + :param classifiedmaterial + :type classifiedmaterial:ifcmaterial + ''' + def __init__( self , materialclassifications,classifiedmaterial, ): + self.materialclassifications = materialclassifications + self.classifiedmaterial = classifiedmaterial + + @apply + def materialclassifications(): + def fget( self ): + return self._materialclassifications + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument materialclassifications is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcclassificationnotationselect', scope = schema_scope)): + self._materialclassifications = SET(value) + else: + self._materialclassifications = value + return property(**locals()) + + @apply + def classifiedmaterial(): + def fget( self ): + return self._classifiedmaterial + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument classifiedmaterial is mantatory and can not be set to None') + if not check_type(value,ifcmaterial): + self._classifiedmaterial = ifcmaterial(value) + else: + self._classifiedmaterial = value + return property(**locals()) + +#################### + # ENTITY ifcmechanicalmaterialproperties # +#################### +class ifcmechanicalmaterialproperties(ifcmaterialproperties): + '''Entity ifcmechanicalmaterialproperties definition. + + :param dynamicviscosity + :type dynamicviscosity:ifcdynamicviscositymeasure + + :param youngmodulus + :type youngmodulus:ifcmodulusofelasticitymeasure + + :param shearmodulus + :type shearmodulus:ifcmodulusofelasticitymeasure + + :param poissonratio + :type poissonratio:ifcpositiveratiomeasure + + :param thermalexpansioncoefficient + :type thermalexpansioncoefficient:ifcthermalexpansioncoefficientmeasure + ''' + def __init__( self , inherited0__material , dynamicviscosity,youngmodulus,shearmodulus,poissonratio,thermalexpansioncoefficient, ): + ifcmaterialproperties.__init__(self , inherited0__material , ) + self.dynamicviscosity = dynamicviscosity + self.youngmodulus = youngmodulus + self.shearmodulus = shearmodulus + self.poissonratio = poissonratio + self.thermalexpansioncoefficient = thermalexpansioncoefficient + + @apply + def dynamicviscosity(): + def fget( self ): + return self._dynamicviscosity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdynamicviscositymeasure): + self._dynamicviscosity = ifcdynamicviscositymeasure(value) + else: + self._dynamicviscosity = value + else: + self._dynamicviscosity = value + return property(**locals()) + + @apply + def youngmodulus(): + def fget( self ): + return self._youngmodulus + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofelasticitymeasure): + self._youngmodulus = ifcmodulusofelasticitymeasure(value) + else: + self._youngmodulus = value + else: + self._youngmodulus = value + return property(**locals()) + + @apply + def shearmodulus(): + def fget( self ): + return self._shearmodulus + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofelasticitymeasure): + self._shearmodulus = ifcmodulusofelasticitymeasure(value) + else: + self._shearmodulus = value + else: + self._shearmodulus = value + return property(**locals()) + + @apply + def poissonratio(): + def fget( self ): + return self._poissonratio + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._poissonratio = ifcpositiveratiomeasure(value) + else: + self._poissonratio = value + else: + self._poissonratio = value + return property(**locals()) + + @apply + def thermalexpansioncoefficient(): + def fget( self ): + return self._thermalexpansioncoefficient + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermalexpansioncoefficientmeasure): + self._thermalexpansioncoefficient = ifcthermalexpansioncoefficientmeasure(value) + else: + self._thermalexpansioncoefficient = value + else: + self._thermalexpansioncoefficient = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.youngmodulus)) or (self.youngmodulus >= 0)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (( not EXISTS(self.shearmodulus)) or (self.shearmodulus >= 0)) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcmechanicalconcretematerialproperties # +#################### +class ifcmechanicalconcretematerialproperties(ifcmechanicalmaterialproperties): + '''Entity ifcmechanicalconcretematerialproperties definition. + + :param compressivestrength + :type compressivestrength:ifcpressuremeasure + + :param maxaggregatesize + :type maxaggregatesize:ifcpositivelengthmeasure + + :param admixturesdescription + :type admixturesdescription:ifctext + + :param workability + :type workability:ifctext + + :param protectiveporeratio + :type protectiveporeratio:ifcnormalisedratiomeasure + + :param waterimpermeability + :type waterimpermeability:ifctext + ''' + def __init__( self , inherited0__material , inherited1__dynamicviscosity , inherited2__youngmodulus , inherited3__shearmodulus , inherited4__poissonratio , inherited5__thermalexpansioncoefficient , compressivestrength,maxaggregatesize,admixturesdescription,workability,protectiveporeratio,waterimpermeability, ): + ifcmechanicalmaterialproperties.__init__(self , inherited0__material , inherited1__dynamicviscosity , inherited2__youngmodulus , inherited3__shearmodulus , inherited4__poissonratio , inherited5__thermalexpansioncoefficient , ) + self.compressivestrength = compressivestrength + self.maxaggregatesize = maxaggregatesize + self.admixturesdescription = admixturesdescription + self.workability = workability + self.protectiveporeratio = protectiveporeratio + self.waterimpermeability = waterimpermeability + + @apply + def compressivestrength(): + def fget( self ): + return self._compressivestrength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpressuremeasure): + self._compressivestrength = ifcpressuremeasure(value) + else: + self._compressivestrength = value + else: + self._compressivestrength = value + return property(**locals()) + + @apply + def maxaggregatesize(): + def fget( self ): + return self._maxaggregatesize + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._maxaggregatesize = ifcpositivelengthmeasure(value) + else: + self._maxaggregatesize = value + else: + self._maxaggregatesize = value + return property(**locals()) + + @apply + def admixturesdescription(): + def fget( self ): + return self._admixturesdescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._admixturesdescription = ifctext(value) + else: + self._admixturesdescription = value + else: + self._admixturesdescription = value + return property(**locals()) + + @apply + def workability(): + def fget( self ): + return self._workability + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._workability = ifctext(value) + else: + self._workability = value + else: + self._workability = value + return property(**locals()) + + @apply + def protectiveporeratio(): + def fget( self ): + return self._protectiveporeratio + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._protectiveporeratio = ifcnormalisedratiomeasure(value) + else: + self._protectiveporeratio = value + else: + self._protectiveporeratio = value + return property(**locals()) + + @apply + def waterimpermeability(): + def fget( self ): + return self._waterimpermeability + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._waterimpermeability = ifctext(value) + else: + self._waterimpermeability = value + else: + self._waterimpermeability = value + return property(**locals()) + +#################### + # ENTITY ifcrelconnectselements # +#################### +class ifcrelconnectselements(ifcrelconnects): + '''Entity ifcrelconnectselements definition. + + :param connectiongeometry + :type connectiongeometry:ifcconnectiongeometry + + :param relatingelement + :type relatingelement:ifcelement + + :param relatedelement + :type relatedelement:ifcelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , connectiongeometry,relatingelement,relatedelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.connectiongeometry = connectiongeometry + self.relatingelement = relatingelement + self.relatedelement = relatedelement + + @apply + def connectiongeometry(): + def fget( self ): + return self._connectiongeometry + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcconnectiongeometry): + self._connectiongeometry = ifcconnectiongeometry(value) + else: + self._connectiongeometry = value + else: + self._connectiongeometry = value + return property(**locals()) + + @apply + def relatingelement(): + def fget( self ): + return self._relatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingelement = ifcelement(value) + else: + self._relatingelement = value + return property(**locals()) + + @apply + def relatedelement(): + def fget( self ): + return self._relatedelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatedelement = ifcelement(value) + else: + self._relatedelement = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (self.relatingelement != self.relatedelement) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcshapeaspect # +#################### +class ifcshapeaspect(BaseEntityClass): + '''Entity ifcshapeaspect definition. + + :param shaperepresentations + :type shaperepresentations:LIST(1,None,'ifcshapemodel', scope = schema_scope) + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param productdefinitional + :type productdefinitional:LOGICAL + + :param partofproductdefinitionshape + :type partofproductdefinitionshape:ifcproductdefinitionshape + ''' + def __init__( self , shaperepresentations,name,description,productdefinitional,partofproductdefinitionshape, ): + self.shaperepresentations = shaperepresentations + self.name = name + self.description = description + self.productdefinitional = productdefinitional + self.partofproductdefinitionshape = partofproductdefinitionshape + + @apply + def shaperepresentations(): + def fget( self ): + return self._shaperepresentations + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument shaperepresentations is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcshapemodel', scope = schema_scope)): + self._shaperepresentations = LIST(value) + else: + self._shaperepresentations = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def productdefinitional(): + def fget( self ): + return self._productdefinitional + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument productdefinitional is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._productdefinitional = LOGICAL(value) + else: + self._productdefinitional = value + return property(**locals()) + + @apply + def partofproductdefinitionshape(): + def fget( self ): + return self._partofproductdefinitionshape + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument partofproductdefinitionshape is mantatory and can not be set to None') + if not check_type(value,ifcproductdefinitionshape): + self._partofproductdefinitionshape = ifcproductdefinitionshape(value) + else: + self._partofproductdefinitionshape = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralcurveconnection # +#################### +class ifcstructuralcurveconnection(ifcstructuralconnection): + '''Entity ifcstructuralcurveconnection definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ): + ifcstructuralconnection.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ) + +#################### + # ENTITY ifcushapeprofiledef # +#################### +class ifcushapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifcushapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param flangewidth + :type flangewidth:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param flangethickness + :type flangethickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcpositivelengthmeasure + + :param edgeradius + :type edgeradius:ifcpositivelengthmeasure + + :param flangeslope + :type flangeslope:ifcplaneanglemeasure + + :param centreofgravityinx + :type centreofgravityinx:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,flangewidth,webthickness,flangethickness,filletradius,edgeradius,flangeslope,centreofgravityinx, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.flangewidth = flangewidth + self.webthickness = webthickness + self.flangethickness = flangethickness + self.filletradius = filletradius + self.edgeradius = edgeradius + self.flangeslope = flangeslope + self.centreofgravityinx = centreofgravityinx + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def flangewidth(): + def fget( self ): + return self._flangewidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangewidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangewidth = ifcpositivelengthmeasure(value) + else: + self._flangewidth = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def flangethickness(): + def fget( self ): + return self._flangethickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangethickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangethickness = ifcpositivelengthmeasure(value) + else: + self._flangethickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._filletradius = ifcpositivelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + + @apply + def edgeradius(): + def fget( self ): + return self._edgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._edgeradius = ifcpositivelengthmeasure(value) + else: + self._edgeradius = value + else: + self._edgeradius = value + return property(**locals()) + + @apply + def flangeslope(): + def fget( self ): + return self._flangeslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._flangeslope = ifcplaneanglemeasure(value) + else: + self._flangeslope = value + else: + self._flangeslope = value + return property(**locals()) + + @apply + def centreofgravityinx(): + def fget( self ): + return self._centreofgravityinx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._centreofgravityinx = ifcpositivelengthmeasure(value) + else: + self._centreofgravityinx = value + else: + self._centreofgravityinx = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (self.flangethickness < (self.depth / 2)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.webthickness < self.flangewidth) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcexternallydefinedsurfacestyle # +#################### +class ifcexternallydefinedsurfacestyle(ifcexternalreference): + '''Entity ifcexternallydefinedsurfacestyle definition. + ''' + def __init__( self , inherited0__location , inherited1__itemreference , inherited2__name , ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__itemreference , inherited2__name , ) + +#################### + # ENTITY ifcannotationsurfaceoccurrence # +#################### +class ifcannotationsurfaceoccurrence(ifcannotationoccurrence): + '''Entity ifcannotationsurfaceoccurrence definition. + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , ): + ifcannotationoccurrence.__init__(self , inherited0__item , inherited1__styles , inherited2__name , ) + def wr31(self): + eval_wr31_wr = (( not EXISTS(self.self.ifcstyleditem.self.item)) or (SIZEOF(['IFC2X3.IFCSURFACE','IFC2X3.IFCFACEBASEDSURFACEMODEL','IFC2X3.IFCSHELLBASEDSURFACEMODEL','IFC2X3.IFCSOLIDMODEL'] * TYPEOF(self.self.ifcstyleditem.self.item)) > 0)) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcevaporatortype # +#################### +class ifcevaporatortype(ifcenergyconversiondevicetype): + '''Entity ifcevaporatortype definition. + + :param predefinedtype + :type predefinedtype:ifcevaporatortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcevaporatortypeenum): + self._predefinedtype = ifcevaporatortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcevaporatortypeenum.self.userdefined) or ((self.predefinedtype == ifcevaporatortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcfurniturestandard # +#################### +class ifcfurniturestandard(ifccontrol): + '''Entity ifcfurniturestandard definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + +#################### + # ENTITY ifcrectangleprofiledef # +#################### +class ifcrectangleprofiledef(ifcparameterizedprofiledef): + '''Entity ifcrectangleprofiledef definition. + + :param xdim + :type xdim:ifcpositivelengthmeasure + + :param ydim + :type ydim:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , xdim,ydim, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.xdim = xdim + self.ydim = ydim + + @apply + def xdim(): + def fget( self ): + return self._xdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument xdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._xdim = ifcpositivelengthmeasure(value) + else: + self._xdim = value + return property(**locals()) + + @apply + def ydim(): + def fget( self ): + return self._ydim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ydim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ydim = ifcpositivelengthmeasure(value) + else: + self._ydim = value + return property(**locals()) + +#################### + # ENTITY ifcroundedrectangleprofiledef # +#################### +class ifcroundedrectangleprofiledef(ifcrectangleprofiledef): + '''Entity ifcroundedrectangleprofiledef definition. + + :param roundingradius + :type roundingradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__xdim , inherited4__ydim , roundingradius, ): + ifcrectangleprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__xdim , inherited4__ydim , ) + self.roundingradius = roundingradius + + @apply + def roundingradius(): + def fget( self ): + return self._roundingradius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument roundingradius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._roundingradius = ifcpositivelengthmeasure(value) + else: + self._roundingradius = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = ((self.roundingradius <= (self.self.ifcrectangleprofiledef.self.xdim / 2)) and (self.roundingradius <= (self.self.ifcrectangleprofiledef.self.ydim / 2))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifctshapeprofiledef # +#################### +class ifctshapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifctshapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param flangewidth + :type flangewidth:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param flangethickness + :type flangethickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcpositivelengthmeasure + + :param flangeedgeradius + :type flangeedgeradius:ifcpositivelengthmeasure + + :param webedgeradius + :type webedgeradius:ifcpositivelengthmeasure + + :param webslope + :type webslope:ifcplaneanglemeasure + + :param flangeslope + :type flangeslope:ifcplaneanglemeasure + + :param centreofgravityiny + :type centreofgravityiny:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,flangewidth,webthickness,flangethickness,filletradius,flangeedgeradius,webedgeradius,webslope,flangeslope,centreofgravityiny, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.flangewidth = flangewidth + self.webthickness = webthickness + self.flangethickness = flangethickness + self.filletradius = filletradius + self.flangeedgeradius = flangeedgeradius + self.webedgeradius = webedgeradius + self.webslope = webslope + self.flangeslope = flangeslope + self.centreofgravityiny = centreofgravityiny + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def flangewidth(): + def fget( self ): + return self._flangewidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangewidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangewidth = ifcpositivelengthmeasure(value) + else: + self._flangewidth = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def flangethickness(): + def fget( self ): + return self._flangethickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangethickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangethickness = ifcpositivelengthmeasure(value) + else: + self._flangethickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._filletradius = ifcpositivelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + + @apply + def flangeedgeradius(): + def fget( self ): + return self._flangeedgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._flangeedgeradius = ifcpositivelengthmeasure(value) + else: + self._flangeedgeradius = value + else: + self._flangeedgeradius = value + return property(**locals()) + + @apply + def webedgeradius(): + def fget( self ): + return self._webedgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._webedgeradius = ifcpositivelengthmeasure(value) + else: + self._webedgeradius = value + else: + self._webedgeradius = value + return property(**locals()) + + @apply + def webslope(): + def fget( self ): + return self._webslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._webslope = ifcplaneanglemeasure(value) + else: + self._webslope = value + else: + self._webslope = value + return property(**locals()) + + @apply + def flangeslope(): + def fget( self ): + return self._flangeslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._flangeslope = ifcplaneanglemeasure(value) + else: + self._flangeslope = value + else: + self._flangeslope = value + return property(**locals()) + + @apply + def centreofgravityiny(): + def fget( self ): + return self._centreofgravityiny + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._centreofgravityiny = ifcpositivelengthmeasure(value) + else: + self._centreofgravityiny = value + else: + self._centreofgravityiny = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.flangethickness < self.depth) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.webthickness < self.flangewidth) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcelectricappliancetype # +#################### +class ifcelectricappliancetype(ifcflowterminaltype): + '''Entity ifcelectricappliancetype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricappliancetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricappliancetypeenum): + self._predefinedtype = ifcelectricappliancetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcgasterminaltype # +#################### +class ifcgasterminaltype(ifcflowterminaltype): + '''Entity ifcgasterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcgasterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcgasterminaltypeenum): + self._predefinedtype = ifcgasterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcgasterminaltypeenum.self.userdefined) or ((self.predefinedtype == ifcgasterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifctextliteral # +#################### +class ifctextliteral(ifcgeometricrepresentationitem): + '''Entity ifctextliteral definition. + + :param literal + :type literal:ifcpresentabletext + + :param placement + :type placement:ifcaxis2placement + + :param path + :type path:ifctextpath + ''' + def __init__( self , literal,placement,path, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.literal = literal + self.placement = placement + self.path = path + + @apply + def literal(): + def fget( self ): + return self._literal + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument literal is mantatory and can not be set to None') + if not check_type(value,ifcpresentabletext): + self._literal = ifcpresentabletext(value) + else: + self._literal = value + return property(**locals()) + + @apply + def placement(): + def fget( self ): + return self._placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placement is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._placement = ifcaxis2placement(value) + else: + self._placement = value + return property(**locals()) + + @apply + def path(): + def fget( self ): + return self._path + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument path is mantatory and can not be set to None') + if not check_type(value,ifctextpath): + self._path = ifctextpath(value) + else: + self._path = value + return property(**locals()) + +#################### + # ENTITY ifcdocumentinformation # +#################### +class ifcdocumentinformation(BaseEntityClass): + '''Entity ifcdocumentinformation definition. + + :param documentid + :type documentid:ifcidentifier + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param documentreferences + :type documentreferences:SET(1,None,'ifcdocumentreference', scope = schema_scope) + + :param purpose + :type purpose:ifctext + + :param intendeduse + :type intendeduse:ifctext + + :param scope + :type scope:ifctext + + :param revision + :type revision:ifclabel + + :param documentowner + :type documentowner:ifcactorselect + + :param editors + :type editors:SET(1,None,'ifcactorselect', scope = schema_scope) + + :param creationtime + :type creationtime:ifcdateandtime + + :param lastrevisiontime + :type lastrevisiontime:ifcdateandtime + + :param electronicformat + :type electronicformat:ifcdocumentelectronicformat + + :param validfrom + :type validfrom:ifccalendardate + + :param validuntil + :type validuntil:ifccalendardate + + :param confidentiality + :type confidentiality:ifcdocumentconfidentialityenum + + :param status + :type status:ifcdocumentstatusenum + + :param ispointedto + :type ispointedto:SET(0,None,'ifcdocumentinformationrelationship', scope = schema_scope) + + :param ispointer + :type ispointer:SET(0,1,'ifcdocumentinformationrelationship', scope = schema_scope) + ''' + def __init__( self , documentid,name,description,documentreferences,purpose,intendeduse,scope,revision,documentowner,editors,creationtime,lastrevisiontime,electronicformat,validfrom,validuntil,confidentiality,status, ): + self.documentid = documentid + self.name = name + self.description = description + self.documentreferences = documentreferences + self.purpose = purpose + self.intendeduse = intendeduse + self.scope = scope + self.revision = revision + self.documentowner = documentowner + self.editors = editors + self.creationtime = creationtime + self.lastrevisiontime = lastrevisiontime + self.electronicformat = electronicformat + self.validfrom = validfrom + self.validuntil = validuntil + self.confidentiality = confidentiality + self.status = status + + @apply + def documentid(): + def fget( self ): + return self._documentid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument documentid is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._documentid = ifcidentifier(value) + else: + self._documentid = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def documentreferences(): + def fget( self ): + return self._documentreferences + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcdocumentreference', scope = schema_scope)): + self._documentreferences = SET(value) + else: + self._documentreferences = value + else: + self._documentreferences = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._purpose = ifctext(value) + else: + self._purpose = value + else: + self._purpose = value + return property(**locals()) + + @apply + def intendeduse(): + def fget( self ): + return self._intendeduse + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._intendeduse = ifctext(value) + else: + self._intendeduse = value + else: + self._intendeduse = value + return property(**locals()) + + @apply + def scope(): + def fget( self ): + return self._scope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._scope = ifctext(value) + else: + self._scope = value + else: + self._scope = value + return property(**locals()) + + @apply + def revision(): + def fget( self ): + return self._revision + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._revision = ifclabel(value) + else: + self._revision = value + else: + self._revision = value + return property(**locals()) + + @apply + def documentowner(): + def fget( self ): + return self._documentowner + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._documentowner = ifcactorselect(value) + else: + self._documentowner = value + else: + self._documentowner = value + return property(**locals()) + + @apply + def editors(): + def fget( self ): + return self._editors + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcactorselect', scope = schema_scope)): + self._editors = SET(value) + else: + self._editors = value + else: + self._editors = value + return property(**locals()) + + @apply + def creationtime(): + def fget( self ): + return self._creationtime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdateandtime): + self._creationtime = ifcdateandtime(value) + else: + self._creationtime = value + else: + self._creationtime = value + return property(**locals()) + + @apply + def lastrevisiontime(): + def fget( self ): + return self._lastrevisiontime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdateandtime): + self._lastrevisiontime = ifcdateandtime(value) + else: + self._lastrevisiontime = value + else: + self._lastrevisiontime = value + return property(**locals()) + + @apply + def electronicformat(): + def fget( self ): + return self._electronicformat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdocumentelectronicformat): + self._electronicformat = ifcdocumentelectronicformat(value) + else: + self._electronicformat = value + else: + self._electronicformat = value + return property(**locals()) + + @apply + def validfrom(): + def fget( self ): + return self._validfrom + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccalendardate): + self._validfrom = ifccalendardate(value) + else: + self._validfrom = value + else: + self._validfrom = value + return property(**locals()) + + @apply + def validuntil(): + def fget( self ): + return self._validuntil + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccalendardate): + self._validuntil = ifccalendardate(value) + else: + self._validuntil = value + else: + self._validuntil = value + return property(**locals()) + + @apply + def confidentiality(): + def fget( self ): + return self._confidentiality + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdocumentconfidentialityenum): + self._confidentiality = ifcdocumentconfidentialityenum(value) + else: + self._confidentiality = value + else: + self._confidentiality = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdocumentstatusenum): + self._status = ifcdocumentstatusenum(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def ispointedto(): + def fget( self ): + return self._ispointedto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ispointedto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ispointer(): + def fget( self ): + return self._ispointer + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ispointer is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstylemodel # +#################### +class ifcstylemodel(ifcrepresentation): + '''Entity ifcstylemodel definition. + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcrepresentation.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + +#################### + # ENTITY ifcstyledrepresentation # +#################### +class ifcstyledrepresentation(ifcstylemodel): + '''Entity ifcstyledrepresentation definition. + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcstylemodel.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcellipseprofiledef # +#################### +class ifcellipseprofiledef(ifcparameterizedprofiledef): + '''Entity ifcellipseprofiledef definition. + + :param semiaxis1 + :type semiaxis1:ifcpositivelengthmeasure + + :param semiaxis2 + :type semiaxis2:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , semiaxis1,semiaxis2, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.semiaxis1 = semiaxis1 + self.semiaxis2 = semiaxis2 + + @apply + def semiaxis1(): + def fget( self ): + return self._semiaxis1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semiaxis1 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._semiaxis1 = ifcpositivelengthmeasure(value) + else: + self._semiaxis1 = value + return property(**locals()) + + @apply + def semiaxis2(): + def fget( self ): + return self._semiaxis2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semiaxis2 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._semiaxis2 = ifcpositivelengthmeasure(value) + else: + self._semiaxis2 = value + return property(**locals()) + +#################### + # ENTITY ifcsectionedspine # +#################### +class ifcsectionedspine(ifcgeometricrepresentationitem): + '''Entity ifcsectionedspine definition. + + :param spinecurve + :type spinecurve:ifccompositecurve + + :param crosssections + :type crosssections:LIST(2,None,'ifcprofiledef', scope = schema_scope) + + :param crosssectionpositions + :type crosssectionpositions:LIST(2,None,'ifcaxis2placement3d', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , spinecurve,crosssections,crosssectionpositions, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.spinecurve = spinecurve + self.crosssections = crosssections + self.crosssectionpositions = crosssectionpositions + + @apply + def spinecurve(): + def fget( self ): + return self._spinecurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument spinecurve is mantatory and can not be set to None') + if not check_type(value,ifccompositecurve): + self._spinecurve = ifccompositecurve(value) + else: + self._spinecurve = value + return property(**locals()) + + @apply + def crosssections(): + def fget( self ): + return self._crosssections + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument crosssections is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'ifcprofiledef', scope = schema_scope)): + self._crosssections = LIST(value) + else: + self._crosssections = value + return property(**locals()) + + @apply + def crosssectionpositions(): + def fget( self ): + return self._crosssectionpositions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument crosssectionpositions is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'ifcaxis2placement3d', scope = schema_scope)): + self._crosssectionpositions = LIST(value) + else: + self._crosssectionpositions = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.crosssections) == SIZEOF(self.crosssectionpositions)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.spinecurve.self.dim == 3) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcvertex # +#################### +class ifcvertex(ifctopologicalrepresentationitem): + '''Entity ifcvertex definition. + ''' + def __init__( self , ): + ifctopologicalrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifcvertexpoint # +#################### +class ifcvertexpoint(ifcvertex): + '''Entity ifcvertexpoint definition. + + :param vertexgeometry + :type vertexgeometry:ifcpoint + ''' + def __init__( self , vertexgeometry, ): + ifcvertex.__init__(self , ) + self.vertexgeometry = vertexgeometry + + @apply + def vertexgeometry(): + def fget( self ): + return self._vertexgeometry + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vertexgeometry is mantatory and can not be set to None') + if not check_type(value,ifcpoint): + self._vertexgeometry = ifcpoint(value) + else: + self._vertexgeometry = value + return property(**locals()) + +#################### + # ENTITY ifcwallstandardcase # +#################### +class ifcwallstandardcase(ifcwall): + '''Entity ifcwallstandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcwall.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccablecarriersegmenttype # +#################### +class ifccablecarriersegmenttype(ifcflowsegmenttype): + '''Entity ifccablecarriersegmenttype definition. + + :param predefinedtype + :type predefinedtype:ifccablecarriersegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowsegmenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccablecarriersegmenttypeenum): + self._predefinedtype = ifccablecarriersegmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcdraughtingcallout # +#################### +class ifcdraughtingcallout(ifcgeometricrepresentationitem): + '''Entity ifcdraughtingcallout definition. + + :param contents + :type contents:SET(1,None,'ifcdraughtingcalloutelement', scope = schema_scope) + + :param isrelatedfromcallout + :type isrelatedfromcallout:SET(0,None,'ifcdraughtingcalloutrelationship', scope = schema_scope) + + :param isrelatedtocallout + :type isrelatedtocallout:SET(0,None,'ifcdraughtingcalloutrelationship', scope = schema_scope) + ''' + def __init__( self , contents, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.contents = contents + + @apply + def contents(): + def fget( self ): + return self._contents + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument contents is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcdraughtingcalloutelement', scope = schema_scope)): + self._contents = SET(value) + else: + self._contents = value + return property(**locals()) + + @apply + def isrelatedfromcallout(): + def fget( self ): + return self._isrelatedfromcallout + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isrelatedfromcallout is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isrelatedtocallout(): + def fget( self ): + return self._isrelatedtocallout + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isrelatedtocallout is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcdimensioncurvedirectedcallout # +#################### +class ifcdimensioncurvedirectedcallout(ifcdraughtingcallout): + '''Entity ifcdimensioncurvedirectedcallout definition. + ''' + def __init__( self , inherited0__contents , ): + ifcdraughtingcallout.__init__(self , inherited0__contents , ) + def wr41(self): + eval_wr41_wr = (SIZEOF(None) == 1) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + def wr42(self): + eval_wr42_wr = (SIZEOF(None) <= 2) + if not eval_wr42_wr: + raise AssertionError('Rule wr42 violated') + else: + return eval_wr42_wr + + +#################### + # ENTITY ifcdiameterdimension # +#################### +class ifcdiameterdimension(ifcdimensioncurvedirectedcallout): + '''Entity ifcdiameterdimension definition. + ''' + def __init__( self , inherited0__contents , ): + ifcdimensioncurvedirectedcallout.__init__(self , inherited0__contents , ) + +#################### + # ENTITY ifcfeatureelementsubtraction # +#################### +class ifcfeatureelementsubtraction(ifcfeatureelement): + '''Entity ifcfeatureelementsubtraction definition. + + :param voidselements + :type voidselements:ifcrelvoidselement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcfeatureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def voidselements(): + def fget( self ): + return self._voidselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument voidselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcedgefeature # +#################### +class ifcedgefeature(ifcfeatureelementsubtraction): + '''Entity ifcedgefeature definition. + + :param featurelength + :type featurelength:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , featurelength, ): + ifcfeatureelementsubtraction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.featurelength = featurelength + + @apply + def featurelength(): + def fget( self ): + return self._featurelength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._featurelength = ifcpositivelengthmeasure(value) + else: + self._featurelength = value + else: + self._featurelength = value + return property(**locals()) + +#################### + # ENTITY ifcroundededgefeature # +#################### +class ifcroundededgefeature(ifcedgefeature): + '''Entity ifcroundededgefeature definition. + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__featurelength , radius, ): + ifcedgefeature.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__featurelength , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifcductsilencertype # +#################### +class ifcductsilencertype(ifcflowtreatmentdevicetype): + '''Entity ifcductsilencertype definition. + + :param predefinedtype + :type predefinedtype:ifcductsilencertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowtreatmentdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcductsilencertypeenum): + self._predefinedtype = ifcductsilencertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcductsilencertypeenum.self.userdefined) or ((self.predefinedtype == ifcductsilencertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelaxation # +#################### +class ifcrelaxation(BaseEntityClass): + '''Entity ifcrelaxation definition. + + :param relaxationvalue + :type relaxationvalue:ifcnormalisedratiomeasure + + :param initialstress + :type initialstress:ifcnormalisedratiomeasure + ''' + def __init__( self , relaxationvalue,initialstress, ): + self.relaxationvalue = relaxationvalue + self.initialstress = initialstress + + @apply + def relaxationvalue(): + def fget( self ): + return self._relaxationvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relaxationvalue is mantatory and can not be set to None') + if not check_type(value,ifcnormalisedratiomeasure): + self._relaxationvalue = ifcnormalisedratiomeasure(value) + else: + self._relaxationvalue = value + return property(**locals()) + + @apply + def initialstress(): + def fget( self ): + return self._initialstress + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument initialstress is mantatory and can not be set to None') + if not check_type(value,ifcnormalisedratiomeasure): + self._initialstress = ifcnormalisedratiomeasure(value) + else: + self._initialstress = value + return property(**locals()) + +#################### + # ENTITY ifcishapeprofiledef # +#################### +class ifcishapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifcishapeprofiledef definition. + + :param overallwidth + :type overallwidth:ifcpositivelengthmeasure + + :param overalldepth + :type overalldepth:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param flangethickness + :type flangethickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , overallwidth,overalldepth,webthickness,flangethickness,filletradius, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.overallwidth = overallwidth + self.overalldepth = overalldepth + self.webthickness = webthickness + self.flangethickness = flangethickness + self.filletradius = filletradius + + @apply + def overallwidth(): + def fget( self ): + return self._overallwidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument overallwidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._overallwidth = ifcpositivelengthmeasure(value) + else: + self._overallwidth = value + return property(**locals()) + + @apply + def overalldepth(): + def fget( self ): + return self._overalldepth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument overalldepth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._overalldepth = ifcpositivelengthmeasure(value) + else: + self._overalldepth = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def flangethickness(): + def fget( self ): + return self._flangethickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangethickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangethickness = ifcpositivelengthmeasure(value) + else: + self._flangethickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._filletradius = ifcpositivelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.flangethickness < (self.overalldepth / 2)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.webthickness < self.overallwidth) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not EXISTS(self.filletradius)) or ((self.filletradius <= ((self.overallwidth - self.webthickness) / 2)) and (self.filletradius <= ((self.overalldepth - (2 * self.flangethickness)) / 2)))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcasymmetricishapeprofiledef # +#################### +class ifcasymmetricishapeprofiledef(ifcishapeprofiledef): + '''Entity ifcasymmetricishapeprofiledef definition. + + :param topflangewidth + :type topflangewidth:ifcpositivelengthmeasure + + :param topflangethickness + :type topflangethickness:ifcpositivelengthmeasure + + :param topflangefilletradius + :type topflangefilletradius:ifcpositivelengthmeasure + + :param centreofgravityiny + :type centreofgravityiny:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__overallwidth , inherited4__overalldepth , inherited5__webthickness , inherited6__flangethickness , inherited7__filletradius , topflangewidth,topflangethickness,topflangefilletradius,centreofgravityiny, ): + ifcishapeprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__overallwidth , inherited4__overalldepth , inherited5__webthickness , inherited6__flangethickness , inherited7__filletradius , ) + self.topflangewidth = topflangewidth + self.topflangethickness = topflangethickness + self.topflangefilletradius = topflangefilletradius + self.centreofgravityiny = centreofgravityiny + + @apply + def topflangewidth(): + def fget( self ): + return self._topflangewidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument topflangewidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._topflangewidth = ifcpositivelengthmeasure(value) + else: + self._topflangewidth = value + return property(**locals()) + + @apply + def topflangethickness(): + def fget( self ): + return self._topflangethickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._topflangethickness = ifcpositivelengthmeasure(value) + else: + self._topflangethickness = value + else: + self._topflangethickness = value + return property(**locals()) + + @apply + def topflangefilletradius(): + def fget( self ): + return self._topflangefilletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._topflangefilletradius = ifcpositivelengthmeasure(value) + else: + self._topflangefilletradius = value + else: + self._topflangefilletradius = value + return property(**locals()) + + @apply + def centreofgravityiny(): + def fget( self ): + return self._centreofgravityiny + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._centreofgravityiny = ifcpositivelengthmeasure(value) + else: + self._centreofgravityiny = value + else: + self._centreofgravityiny = value + return property(**locals()) + +#################### + # ENTITY ifcproductsofcombustionproperties # +#################### +class ifcproductsofcombustionproperties(ifcmaterialproperties): + '''Entity ifcproductsofcombustionproperties definition. + + :param specificheatcapacity + :type specificheatcapacity:ifcspecificheatcapacitymeasure + + :param n20content + :type n20content:ifcpositiveratiomeasure + + :param cocontent + :type cocontent:ifcpositiveratiomeasure + + :param co2content + :type co2content:ifcpositiveratiomeasure + ''' + def __init__( self , inherited0__material , specificheatcapacity,n20content,cocontent,co2content, ): + ifcmaterialproperties.__init__(self , inherited0__material , ) + self.specificheatcapacity = specificheatcapacity + self.n20content = n20content + self.cocontent = cocontent + self.co2content = co2content + + @apply + def specificheatcapacity(): + def fget( self ): + return self._specificheatcapacity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcspecificheatcapacitymeasure): + self._specificheatcapacity = ifcspecificheatcapacitymeasure(value) + else: + self._specificheatcapacity = value + else: + self._specificheatcapacity = value + return property(**locals()) + + @apply + def n20content(): + def fget( self ): + return self._n20content + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._n20content = ifcpositiveratiomeasure(value) + else: + self._n20content = value + else: + self._n20content = value + return property(**locals()) + + @apply + def cocontent(): + def fget( self ): + return self._cocontent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._cocontent = ifcpositiveratiomeasure(value) + else: + self._cocontent = value + else: + self._cocontent = value + return property(**locals()) + + @apply + def co2content(): + def fget( self ): + return self._co2content + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._co2content = ifcpositiveratiomeasure(value) + else: + self._co2content = value + else: + self._co2content = value + return property(**locals()) + +#################### + # ENTITY ifccartesiantransformationoperator2d # +#################### +class ifccartesiantransformationoperator2d(ifccartesiantransformationoperator): + '''Entity ifccartesiantransformationoperator2d definition. + + :param u + :type u:LIST(2,2,'ifcdirection', scope = schema_scope) + ''' + def __init__( self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , ): + ifccartesiantransformationoperator.__init__(self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , ) + + @apply + def u(): + def fget( self ): + attribute_eval = ifcbaseaxis(2,self.self.ifccartesiantransformationoperator.self.axis1,self.self.ifccartesiantransformationoperator.self.axis2, None ) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument u is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.ifccartesiantransformationoperator.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not EXISTS(self.self.ifccartesiantransformationoperator.self.axis1)) or (self.self.ifccartesiantransformationoperator.self.axis1.self.dim == 2)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (( not EXISTS(self.self.ifccartesiantransformationoperator.self.axis2)) or (self.self.ifccartesiantransformationoperator.self.axis2.self.dim == 2)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifccartesiantransformationoperator2dnonuniform # +#################### +class ifccartesiantransformationoperator2dnonuniform(ifccartesiantransformationoperator2d): + '''Entity ifccartesiantransformationoperator2dnonuniform definition. + + :param scale2 + :type scale2:REAL + + :param scl2 + :type scl2:REAL + ''' + def __init__( self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , scale2, ): + ifccartesiantransformationoperator2d.__init__(self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , ) + self.scale2 = scale2 + + @apply + def scale2(): + def fget( self ): + return self._scale2 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._scale2 = REAL(value) + else: + self._scale2 = value + else: + self._scale2 = value + return property(**locals()) + + @apply + def scl2(): + def fget( self ): + attribute_eval = NVL(self.scale2,self.self.ifccartesiantransformationoperator.self.scl) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scl2 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.scl2 > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcdateandtime # +#################### +class ifcdateandtime(BaseEntityClass): + '''Entity ifcdateandtime definition. + + :param datecomponent + :type datecomponent:ifccalendardate + + :param timecomponent + :type timecomponent:ifclocaltime + ''' + def __init__( self , datecomponent,timecomponent, ): + self.datecomponent = datecomponent + self.timecomponent = timecomponent + + @apply + def datecomponent(): + def fget( self ): + return self._datecomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument datecomponent is mantatory and can not be set to None') + if not check_type(value,ifccalendardate): + self._datecomponent = ifccalendardate(value) + else: + self._datecomponent = value + return property(**locals()) + + @apply + def timecomponent(): + def fget( self ): + return self._timecomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timecomponent is mantatory and can not be set to None') + if not check_type(value,ifclocaltime): + self._timecomponent = ifclocaltime(value) + else: + self._timecomponent = value + return property(**locals()) + +#################### + # ENTITY ifcelementassembly # +#################### +class ifcelementassembly(ifcelement): + '''Entity ifcelementassembly definition. + + :param assemblyplace + :type assemblyplace:ifcassemblyplaceenum + + :param predefinedtype + :type predefinedtype:ifcelementassemblytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , assemblyplace,predefinedtype, ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.assemblyplace = assemblyplace + self.predefinedtype = predefinedtype + + @apply + def assemblyplace(): + def fget( self ): + return self._assemblyplace + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcassemblyplaceenum): + self._assemblyplace = ifcassemblyplaceenum(value) + else: + self._assemblyplace = value + else: + self._assemblyplace = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelementassemblytypeenum): + self._predefinedtype = ifcelementassemblytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcelementassemblytypeenum.self.userdefined) or ((self.predefinedtype == ifcelementassemblytypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcelementcomponent # +#################### +class ifcelementcomponent(ifcelement): + '''Entity ifcelementcomponent definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcaddress # +#################### +class ifcaddress(BaseEntityClass): + '''Entity ifcaddress definition. + + :param purpose + :type purpose:ifcaddresstypeenum + + :param description + :type description:ifctext + + :param userdefinedpurpose + :type userdefinedpurpose:ifclabel + + :param ofperson + :type ofperson:SET(0,None,'ifcperson', scope = schema_scope) + + :param oforganization + :type oforganization:SET(0,None,'ifcorganization', scope = schema_scope) + ''' + def __init__( self , purpose,description,userdefinedpurpose, ): + self.purpose = purpose + self.description = description + self.userdefinedpurpose = userdefinedpurpose + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaddresstypeenum): + self._purpose = ifcaddresstypeenum(value) + else: + self._purpose = value + else: + self._purpose = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def userdefinedpurpose(): + def fget( self ): + return self._userdefinedpurpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedpurpose = ifclabel(value) + else: + self._userdefinedpurpose = value + else: + self._userdefinedpurpose = value + return property(**locals()) + + @apply + def ofperson(): + def fget( self ): + return self._ofperson + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ofperson is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def oforganization(): + def fget( self ): + return self._oforganization + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument oforganization is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not EXISTS(self.purpose)) or ((self.purpose != ifcaddresstypeenum.self.userdefined) or ((self.purpose == ifcaddresstypeenum.self.userdefined) and EXISTS(self.self.userdefinedpurpose)))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifctelecomaddress # +#################### +class ifctelecomaddress(ifcaddress): + '''Entity ifctelecomaddress definition. + + :param telephonenumbers + :type telephonenumbers:LIST(1,None,'STRING', scope = schema_scope) + + :param facsimilenumbers + :type facsimilenumbers:LIST(1,None,'STRING', scope = schema_scope) + + :param pagernumber + :type pagernumber:ifclabel + + :param electronicmailaddresses + :type electronicmailaddresses:LIST(1,None,'STRING', scope = schema_scope) + + :param wwwhomepageurl + :type wwwhomepageurl:ifclabel + ''' + def __init__( self , inherited0__purpose , inherited1__description , inherited2__userdefinedpurpose , telephonenumbers,facsimilenumbers,pagernumber,electronicmailaddresses,wwwhomepageurl, ): + ifcaddress.__init__(self , inherited0__purpose , inherited1__description , inherited2__userdefinedpurpose , ) + self.telephonenumbers = telephonenumbers + self.facsimilenumbers = facsimilenumbers + self.pagernumber = pagernumber + self.electronicmailaddresses = electronicmailaddresses + self.wwwhomepageurl = wwwhomepageurl + + @apply + def telephonenumbers(): + def fget( self ): + return self._telephonenumbers + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._telephonenumbers = LIST(value) + else: + self._telephonenumbers = value + else: + self._telephonenumbers = value + return property(**locals()) + + @apply + def facsimilenumbers(): + def fget( self ): + return self._facsimilenumbers + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._facsimilenumbers = LIST(value) + else: + self._facsimilenumbers = value + else: + self._facsimilenumbers = value + return property(**locals()) + + @apply + def pagernumber(): + def fget( self ): + return self._pagernumber + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._pagernumber = ifclabel(value) + else: + self._pagernumber = value + else: + self._pagernumber = value + return property(**locals()) + + @apply + def electronicmailaddresses(): + def fget( self ): + return self._electronicmailaddresses + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._electronicmailaddresses = LIST(value) + else: + self._electronicmailaddresses = value + else: + self._electronicmailaddresses = value + return property(**locals()) + + @apply + def wwwhomepageurl(): + def fget( self ): + return self._wwwhomepageurl + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._wwwhomepageurl = ifclabel(value) + else: + self._wwwhomepageurl = value + else: + self._wwwhomepageurl = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((((EXISTS(self.telephonenumbers) or EXISTS(self.pagernumber)) or EXISTS(self.facsimilenumbers)) or EXISTS(self.electronicmailaddresses)) or EXISTS(self.wwwhomepageurl)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccurvestylefontandscaling # +#################### +class ifccurvestylefontandscaling(BaseEntityClass): + '''Entity ifccurvestylefontandscaling definition. + + :param name + :type name:ifclabel + + :param curvefont + :type curvefont:ifccurvestylefontselect + + :param curvefontscaling + :type curvefontscaling:ifcpositiveratiomeasure + ''' + def __init__( self , name,curvefont,curvefontscaling, ): + self.name = name + self.curvefont = curvefont + self.curvefontscaling = curvefontscaling + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def curvefont(): + def fget( self ): + return self._curvefont + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curvefont is mantatory and can not be set to None') + if not check_type(value,ifccurvestylefontselect): + self._curvefont = ifccurvestylefontselect(value) + else: + self._curvefont = value + return property(**locals()) + + @apply + def curvefontscaling(): + def fget( self ): + return self._curvefontscaling + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curvefontscaling is mantatory and can not be set to None') + if not check_type(value,ifcpositiveratiomeasure): + self._curvefontscaling = ifcpositiveratiomeasure(value) + else: + self._curvefontscaling = value + return property(**locals()) + +#################### + # ENTITY ifcsurfaceoflinearextrusion # +#################### +class ifcsurfaceoflinearextrusion(ifcsweptsurface): + '''Entity ifcsurfaceoflinearextrusion definition. + + :param extrudeddirection + :type extrudeddirection:ifcdirection + + :param depth + :type depth:ifclengthmeasure + + :param extrusionaxis + :type extrusionaxis:ifcvector + ''' + def __init__( self , inherited0__sweptcurve , inherited1__position , extrudeddirection,depth, ): + ifcsweptsurface.__init__(self , inherited0__sweptcurve , inherited1__position , ) + self.extrudeddirection = extrudeddirection + self.depth = depth + + @apply + def extrudeddirection(): + def fget( self ): + return self._extrudeddirection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extrudeddirection is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._extrudeddirection = ifcdirection(value) + else: + self._extrudeddirection = value + return property(**locals()) + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._depth = ifclengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def extrusionaxis(): + def fget( self ): + attribute_eval = ((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(self.extrudeddirection,self.depth)) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument extrusionaxis is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr41(self): + eval_wr41_wr = (self.depth > 0) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + +#################### + # ENTITY ifccolumntype # +#################### +class ifccolumntype(ifcbuildingelementtype): + '''Entity ifccolumntype definition. + + :param predefinedtype + :type predefinedtype:ifccolumntypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccolumntypeenum): + self._predefinedtype = ifccolumntypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcproductrepresentation # +#################### +class ifcproductrepresentation(BaseEntityClass): + '''Entity ifcproductrepresentation definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param representations + :type representations:LIST(1,None,'ifcrepresentation', scope = schema_scope) + ''' + def __init__( self , name,description,representations, ): + self.name = name + self.description = description + self.representations = representations + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def representations(): + def fget( self ): + return self._representations + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representations is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcrepresentation', scope = schema_scope)): + self._representations = LIST(value) + else: + self._representations = value + return property(**locals()) + +#################### + # ENTITY ifcmaterialdefinitionrepresentation # +#################### +class ifcmaterialdefinitionrepresentation(ifcproductrepresentation): + '''Entity ifcmaterialdefinitionrepresentation definition. + + :param representedmaterial + :type representedmaterial:ifcmaterial + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__representations , representedmaterial, ): + ifcproductrepresentation.__init__(self , inherited0__name , inherited1__description , inherited2__representations , ) + self.representedmaterial = representedmaterial + + @apply + def representedmaterial(): + def fget( self ): + return self._representedmaterial + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representedmaterial is mantatory and can not be set to None') + if not check_type(value,ifcmaterial): + self._representedmaterial = ifcmaterial(value) + else: + self._representedmaterial = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcreldefines # +#################### +class ifcreldefines(ifcrelationship): + '''Entity ifcreldefines definition. + + :param relatedobjects + :type relatedobjects:SET(1,None,'ifcobject', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedobjects, ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedobjects = relatedobjects + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcobject', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + +#################### + # ENTITY ifcreldefinesbyproperties # +#################### +class ifcreldefinesbyproperties(ifcreldefines): + '''Entity ifcreldefinesbyproperties definition. + + :param relatingpropertydefinition + :type relatingpropertydefinition:ifcpropertysetdefinition + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingpropertydefinition, ): + ifcreldefines.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingpropertydefinition = relatingpropertydefinition + + @apply + def relatingpropertydefinition(): + def fget( self ): + return self._relatingpropertydefinition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingpropertydefinition is mantatory and can not be set to None') + if not check_type(value,ifcpropertysetdefinition): + self._relatingpropertydefinition = ifcpropertysetdefinition(value) + else: + self._relatingpropertydefinition = value + return property(**locals()) + +#################### + # ENTITY ifcreloverridesproperties # +#################### +class ifcreloverridesproperties(ifcreldefinesbyproperties): + '''Entity ifcreloverridesproperties definition. + + :param overridingproperties + :type overridingproperties:SET(1,None,'ifcproperty', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatingpropertydefinition , overridingproperties, ): + ifcreldefinesbyproperties.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatingpropertydefinition , ) + self.overridingproperties = overridingproperties + + @apply + def overridingproperties(): + def fget( self ): + return self._overridingproperties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument overridingproperties is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproperty', scope = schema_scope)): + self._overridingproperties = SET(value) + else: + self._overridingproperties = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.ifcreldefines.self.relatedobjects) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcspacethermalloadproperties # +#################### +class ifcspacethermalloadproperties(ifcpropertysetdefinition): + '''Entity ifcspacethermalloadproperties definition. + + :param applicablevalueratio + :type applicablevalueratio:ifcpositiveratiomeasure + + :param thermalloadsource + :type thermalloadsource:ifcthermalloadsourceenum + + :param propertysource + :type propertysource:ifcpropertysourceenum + + :param sourcedescription + :type sourcedescription:ifctext + + :param maximumvalue + :type maximumvalue:ifcpowermeasure + + :param minimumvalue + :type minimumvalue:ifcpowermeasure + + :param thermalloadtimeseriesvalues + :type thermalloadtimeseriesvalues:ifctimeseries + + :param userdefinedthermalloadsource + :type userdefinedthermalloadsource:ifclabel + + :param userdefinedpropertysource + :type userdefinedpropertysource:ifclabel + + :param thermalloadtype + :type thermalloadtype:ifcthermalloadtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , applicablevalueratio,thermalloadsource,propertysource,sourcedescription,maximumvalue,minimumvalue,thermalloadtimeseriesvalues,userdefinedthermalloadsource,userdefinedpropertysource,thermalloadtype, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.applicablevalueratio = applicablevalueratio + self.thermalloadsource = thermalloadsource + self.propertysource = propertysource + self.sourcedescription = sourcedescription + self.maximumvalue = maximumvalue + self.minimumvalue = minimumvalue + self.thermalloadtimeseriesvalues = thermalloadtimeseriesvalues + self.userdefinedthermalloadsource = userdefinedthermalloadsource + self.userdefinedpropertysource = userdefinedpropertysource + self.thermalloadtype = thermalloadtype + + @apply + def applicablevalueratio(): + def fget( self ): + return self._applicablevalueratio + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._applicablevalueratio = ifcpositiveratiomeasure(value) + else: + self._applicablevalueratio = value + else: + self._applicablevalueratio = value + return property(**locals()) + + @apply + def thermalloadsource(): + def fget( self ): + return self._thermalloadsource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument thermalloadsource is mantatory and can not be set to None') + if not check_type(value,ifcthermalloadsourceenum): + self._thermalloadsource = ifcthermalloadsourceenum(value) + else: + self._thermalloadsource = value + return property(**locals()) + + @apply + def propertysource(): + def fget( self ): + return self._propertysource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument propertysource is mantatory and can not be set to None') + if not check_type(value,ifcpropertysourceenum): + self._propertysource = ifcpropertysourceenum(value) + else: + self._propertysource = value + return property(**locals()) + + @apply + def sourcedescription(): + def fget( self ): + return self._sourcedescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._sourcedescription = ifctext(value) + else: + self._sourcedescription = value + else: + self._sourcedescription = value + return property(**locals()) + + @apply + def maximumvalue(): + def fget( self ): + return self._maximumvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument maximumvalue is mantatory and can not be set to None') + if not check_type(value,ifcpowermeasure): + self._maximumvalue = ifcpowermeasure(value) + else: + self._maximumvalue = value + return property(**locals()) + + @apply + def minimumvalue(): + def fget( self ): + return self._minimumvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpowermeasure): + self._minimumvalue = ifcpowermeasure(value) + else: + self._minimumvalue = value + else: + self._minimumvalue = value + return property(**locals()) + + @apply + def thermalloadtimeseriesvalues(): + def fget( self ): + return self._thermalloadtimeseriesvalues + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimeseries): + self._thermalloadtimeseriesvalues = ifctimeseries(value) + else: + self._thermalloadtimeseriesvalues = value + else: + self._thermalloadtimeseriesvalues = value + return property(**locals()) + + @apply + def userdefinedthermalloadsource(): + def fget( self ): + return self._userdefinedthermalloadsource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedthermalloadsource = ifclabel(value) + else: + self._userdefinedthermalloadsource = value + else: + self._userdefinedthermalloadsource = value + return property(**locals()) + + @apply + def userdefinedpropertysource(): + def fget( self ): + return self._userdefinedpropertysource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedpropertysource = ifclabel(value) + else: + self._userdefinedpropertysource = value + else: + self._userdefinedpropertysource = value + return property(**locals()) + + @apply + def thermalloadtype(): + def fget( self ): + return self._thermalloadtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument thermalloadtype is mantatory and can not be set to None') + if not check_type(value,ifcthermalloadtypeenum): + self._thermalloadtype = ifcthermalloadtypeenum(value) + else: + self._thermalloadtype = value + return property(**locals()) + +#################### + # ENTITY ifcdistributionflowelement # +#################### +class ifcdistributionflowelement(ifcdistributionelement): + '''Entity ifcdistributionflowelement definition. + + :param hascontrolelements + :type hascontrolelements:SET(0,1,'ifcrelflowcontrolelements', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def hascontrolelements(): + def fget( self ): + return self._hascontrolelements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hascontrolelements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcflowstoragedevice # +#################### +class ifcflowstoragedevice(ifcdistributionflowelement): + '''Entity ifcflowstoragedevice definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcmateriallayersetusage # +#################### +class ifcmateriallayersetusage(BaseEntityClass): + '''Entity ifcmateriallayersetusage definition. + + :param forlayerset + :type forlayerset:ifcmateriallayerset + + :param layersetdirection + :type layersetdirection:ifclayersetdirectionenum + + :param directionsense + :type directionsense:ifcdirectionsenseenum + + :param offsetfromreferenceline + :type offsetfromreferenceline:ifclengthmeasure + ''' + def __init__( self , forlayerset,layersetdirection,directionsense,offsetfromreferenceline, ): + self.forlayerset = forlayerset + self.layersetdirection = layersetdirection + self.directionsense = directionsense + self.offsetfromreferenceline = offsetfromreferenceline + + @apply + def forlayerset(): + def fget( self ): + return self._forlayerset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument forlayerset is mantatory and can not be set to None') + if not check_type(value,ifcmateriallayerset): + self._forlayerset = ifcmateriallayerset(value) + else: + self._forlayerset = value + return property(**locals()) + + @apply + def layersetdirection(): + def fget( self ): + return self._layersetdirection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layersetdirection is mantatory and can not be set to None') + if not check_type(value,ifclayersetdirectionenum): + self._layersetdirection = ifclayersetdirectionenum(value) + else: + self._layersetdirection = value + return property(**locals()) + + @apply + def directionsense(): + def fget( self ): + return self._directionsense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directionsense is mantatory and can not be set to None') + if not check_type(value,ifcdirectionsenseenum): + self._directionsense = ifcdirectionsenseenum(value) + else: + self._directionsense = value + return property(**locals()) + + @apply + def offsetfromreferenceline(): + def fget( self ): + return self._offsetfromreferenceline + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument offsetfromreferenceline is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._offsetfromreferenceline = ifclengthmeasure(value) + else: + self._offsetfromreferenceline = value + return property(**locals()) + +#################### + # ENTITY ifcshapemodel # +#################### +class ifcshapemodel(ifcrepresentation): + '''Entity ifcshapemodel definition. + + :param ofshapeaspect + :type ofshapeaspect:SET(0,1,'ifcshapeaspect', scope = schema_scope) + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcrepresentation.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + + @apply + def ofshapeaspect(): + def fget( self ): + return self._ofshapeaspect + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ofshapeaspect is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr11(self): + eval_wr11_wr = ((SIZEOF(self.self.ifcrepresentation.self.ofproductrepresentation) == 1) XOR (SIZEOF(self.self.ifcrepresentation.self.representationmap) == 1) XOR (SIZEOF(self.ofshapeaspect) == 1)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcmateriallayerset # +#################### +class ifcmateriallayerset(BaseEntityClass): + '''Entity ifcmateriallayerset definition. + + :param materiallayers + :type materiallayers:LIST(1,None,'ifcmateriallayer', scope = schema_scope) + + :param layersetname + :type layersetname:ifclabel + + :param totalthickness + :type totalthickness:ifclengthmeasure + ''' + def __init__( self , materiallayers,layersetname, ): + self.materiallayers = materiallayers + self.layersetname = layersetname + + @apply + def materiallayers(): + def fget( self ): + return self._materiallayers + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument materiallayers is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcmateriallayer', scope = schema_scope)): + self._materiallayers = LIST(value) + else: + self._materiallayers = value + return property(**locals()) + + @apply + def layersetname(): + def fget( self ): + return self._layersetname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._layersetname = ifclabel(value) + else: + self._layersetname = value + else: + self._layersetname = value + return property(**locals()) + + @apply + def totalthickness(): + def fget( self ): + attribute_eval = ifcmlstotalthickness(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument totalthickness is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcperformancehistory # +#################### +class ifcperformancehistory(ifccontrol): + '''Entity ifcperformancehistory definition. + + :param lifecyclephase + :type lifecyclephase:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , lifecyclephase, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.lifecyclephase = lifecyclephase + + @apply + def lifecyclephase(): + def fget( self ): + return self._lifecyclephase + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lifecyclephase is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._lifecyclephase = ifclabel(value) + else: + self._lifecyclephase = value + return property(**locals()) + +#################### + # ENTITY ifcductsegmenttype # +#################### +class ifcductsegmenttype(ifcflowsegmenttype): + '''Entity ifcductsegmenttype definition. + + :param predefinedtype + :type predefinedtype:ifcductsegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowsegmenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcductsegmenttypeenum): + self._predefinedtype = ifcductsegmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcductsegmenttypeenum.self.userdefined) or ((self.predefinedtype == ifcductsegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcribplateprofileproperties # +#################### +class ifcribplateprofileproperties(ifcprofileproperties): + '''Entity ifcribplateprofileproperties definition. + + :param thickness + :type thickness:ifcpositivelengthmeasure + + :param ribheight + :type ribheight:ifcpositivelengthmeasure + + :param ribwidth + :type ribwidth:ifcpositivelengthmeasure + + :param ribspacing + :type ribspacing:ifcpositivelengthmeasure + + :param direction + :type direction:ifcribplatedirectionenum + ''' + def __init__( self , inherited0__profilename , inherited1__profiledefinition , thickness,ribheight,ribwidth,ribspacing,direction, ): + ifcprofileproperties.__init__(self , inherited0__profilename , inherited1__profiledefinition , ) + self.thickness = thickness + self.ribheight = ribheight + self.ribwidth = ribwidth + self.ribspacing = ribspacing + self.direction = direction + + @apply + def thickness(): + def fget( self ): + return self._thickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._thickness = ifcpositivelengthmeasure(value) + else: + self._thickness = value + else: + self._thickness = value + return property(**locals()) + + @apply + def ribheight(): + def fget( self ): + return self._ribheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._ribheight = ifcpositivelengthmeasure(value) + else: + self._ribheight = value + else: + self._ribheight = value + return property(**locals()) + + @apply + def ribwidth(): + def fget( self ): + return self._ribwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._ribwidth = ifcpositivelengthmeasure(value) + else: + self._ribwidth = value + else: + self._ribwidth = value + return property(**locals()) + + @apply + def ribspacing(): + def fget( self ): + return self._ribspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._ribspacing = ifcpositivelengthmeasure(value) + else: + self._ribspacing = value + else: + self._ribspacing = value + return property(**locals()) + + @apply + def direction(): + def fget( self ): + return self._direction + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument direction is mantatory and can not be set to None') + if not check_type(value,ifcribplatedirectionenum): + self._direction = ifcribplatedirectionenum(value) + else: + self._direction = value + return property(**locals()) + +#################### + # ENTITY ifcdampertype # +#################### +class ifcdampertype(ifcflowcontrollertype): + '''Entity ifcdampertype definition. + + :param predefinedtype + :type predefinedtype:ifcdampertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcdampertypeenum): + self._predefinedtype = ifcdampertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcdampertypeenum.self.userdefined) or ((self.predefinedtype == ifcdampertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcphysicalquantity # +#################### +class ifcphysicalquantity(BaseEntityClass): + '''Entity ifcphysicalquantity definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param partofcomplex + :type partofcomplex:SET(0,1,'ifcphysicalcomplexquantity', scope = schema_scope) + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def partofcomplex(): + def fget( self ): + return self._partofcomplex + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofcomplex is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcphysicalsimplequantity # +#################### +class ifcphysicalsimplequantity(ifcphysicalquantity): + '''Entity ifcphysicalsimplequantity definition. + + :param unit + :type unit:ifcnamedunit + ''' + def __init__( self , inherited0__name , inherited1__description , unit, ): + ifcphysicalquantity.__init__(self , inherited0__name , inherited1__description , ) + self.unit = unit + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnamedunit): + self._unit = ifcnamedunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + +#################### + # ENTITY ifcwindowliningproperties # +#################### +class ifcwindowliningproperties(ifcpropertysetdefinition): + '''Entity ifcwindowliningproperties definition. + + :param liningdepth + :type liningdepth:ifcpositivelengthmeasure + + :param liningthickness + :type liningthickness:ifcpositivelengthmeasure + + :param transomthickness + :type transomthickness:ifcpositivelengthmeasure + + :param mullionthickness + :type mullionthickness:ifcpositivelengthmeasure + + :param firsttransomoffset + :type firsttransomoffset:ifcnormalisedratiomeasure + + :param secondtransomoffset + :type secondtransomoffset:ifcnormalisedratiomeasure + + :param firstmullionoffset + :type firstmullionoffset:ifcnormalisedratiomeasure + + :param secondmullionoffset + :type secondmullionoffset:ifcnormalisedratiomeasure + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , liningdepth,liningthickness,transomthickness,mullionthickness,firsttransomoffset,secondtransomoffset,firstmullionoffset,secondmullionoffset,shapeaspectstyle, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.liningdepth = liningdepth + self.liningthickness = liningthickness + self.transomthickness = transomthickness + self.mullionthickness = mullionthickness + self.firsttransomoffset = firsttransomoffset + self.secondtransomoffset = secondtransomoffset + self.firstmullionoffset = firstmullionoffset + self.secondmullionoffset = secondmullionoffset + self.shapeaspectstyle = shapeaspectstyle + + @apply + def liningdepth(): + def fget( self ): + return self._liningdepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._liningdepth = ifcpositivelengthmeasure(value) + else: + self._liningdepth = value + else: + self._liningdepth = value + return property(**locals()) + + @apply + def liningthickness(): + def fget( self ): + return self._liningthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._liningthickness = ifcpositivelengthmeasure(value) + else: + self._liningthickness = value + else: + self._liningthickness = value + return property(**locals()) + + @apply + def transomthickness(): + def fget( self ): + return self._transomthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._transomthickness = ifcpositivelengthmeasure(value) + else: + self._transomthickness = value + else: + self._transomthickness = value + return property(**locals()) + + @apply + def mullionthickness(): + def fget( self ): + return self._mullionthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._mullionthickness = ifcpositivelengthmeasure(value) + else: + self._mullionthickness = value + else: + self._mullionthickness = value + return property(**locals()) + + @apply + def firsttransomoffset(): + def fget( self ): + return self._firsttransomoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._firsttransomoffset = ifcnormalisedratiomeasure(value) + else: + self._firsttransomoffset = value + else: + self._firsttransomoffset = value + return property(**locals()) + + @apply + def secondtransomoffset(): + def fget( self ): + return self._secondtransomoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._secondtransomoffset = ifcnormalisedratiomeasure(value) + else: + self._secondtransomoffset = value + else: + self._secondtransomoffset = value + return property(**locals()) + + @apply + def firstmullionoffset(): + def fget( self ): + return self._firstmullionoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._firstmullionoffset = ifcnormalisedratiomeasure(value) + else: + self._firstmullionoffset = value + else: + self._firstmullionoffset = value + return property(**locals()) + + @apply + def secondmullionoffset(): + def fget( self ): + return self._secondmullionoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._secondmullionoffset = ifcnormalisedratiomeasure(value) + else: + self._secondmullionoffset = value + else: + self._secondmullionoffset = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = ( not (( not EXISTS(self.liningdepth)) and EXISTS(self.liningthickness))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = ( not (( not EXISTS(self.firsttransomoffset)) and EXISTS(self.secondtransomoffset))) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + def wr33(self): + eval_wr33_wr = ( not (( not EXISTS(self.firstmullionoffset)) and EXISTS(self.secondmullionoffset))) + if not eval_wr33_wr: + raise AssertionError('Rule wr33 violated') + else: + return eval_wr33_wr + + def wr34(self): + eval_wr34_wr = (EXISTS(self.self.ifcpropertysetdefinition.self.definestype[1]) and ('IFC2X3.IFCWINDOWSTYLE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1]))) + if not eval_wr34_wr: + raise AssertionError('Rule wr34 violated') + else: + return eval_wr34_wr + + +#################### + # ENTITY ifcorganization # +#################### +class ifcorganization(BaseEntityClass): + '''Entity ifcorganization definition. + + :param id + :type id:ifcidentifier + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param roles + :type roles:LIST(1,None,'ifcactorrole', scope = schema_scope) + + :param addresses + :type addresses:LIST(1,None,'ifcaddress', scope = schema_scope) + + :param isrelatedby + :type isrelatedby:SET(0,None,'ifcorganizationrelationship', scope = schema_scope) + + :param relates + :type relates:SET(0,None,'ifcorganizationrelationship', scope = schema_scope) + + :param engages + :type engages:SET(0,None,'ifcpersonandorganization', scope = schema_scope) + ''' + def __init__( self , id,name,description,roles,addresses, ): + self.id = id + self.name = name + self.description = description + self.roles = roles + self.addresses = addresses + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._id = ifcidentifier(value) + else: + self._id = value + else: + self._id = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def roles(): + def fget( self ): + return self._roles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcactorrole', scope = schema_scope)): + self._roles = LIST(value) + else: + self._roles = value + else: + self._roles = value + return property(**locals()) + + @apply + def addresses(): + def fget( self ): + return self._addresses + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcaddress', scope = schema_scope)): + self._addresses = LIST(value) + else: + self._addresses = value + else: + self._addresses = value + return property(**locals()) + + @apply + def isrelatedby(): + def fget( self ): + return self._isrelatedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isrelatedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def relates(): + def fget( self ): + return self._relates + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument relates is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def engages(): + def fget( self ): + return self._engages + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument engages is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcquantitycount # +#################### +class ifcquantitycount(ifcphysicalsimplequantity): + '''Entity ifcquantitycount definition. + + :param countvalue + :type countvalue:ifccountmeasure + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , countvalue, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.countvalue = countvalue + + @apply + def countvalue(): + def fget( self ): + return self._countvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument countvalue is mantatory and can not be set to None') + if not check_type(value,ifccountmeasure): + self._countvalue = ifccountmeasure(value) + else: + self._countvalue = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (self.countvalue >= 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcannotation # +#################### +class ifcannotation(ifcproduct): + '''Entity ifcannotation definition. + + :param containedinstructure + :type containedinstructure:SET(0,1,'ifcrelcontainedinspatialstructure', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + + @apply + def containedinstructure(): + def fget( self ): + return self._containedinstructure + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containedinstructure is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcfacebasedsurfacemodel # +#################### +class ifcfacebasedsurfacemodel(ifcgeometricrepresentationitem): + '''Entity ifcfacebasedsurfacemodel definition. + + :param fbsmfaces + :type fbsmfaces:SET(1,None,'ifcconnectedfaceset', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , fbsmfaces, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.fbsmfaces = fbsmfaces + + @apply + def fbsmfaces(): + def fget( self ): + return self._fbsmfaces + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fbsmfaces is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcconnectedfaceset', scope = schema_scope)): + self._fbsmfaces = SET(value) + else: + self._fbsmfaces = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcpropertyenumeration # +#################### +class ifcpropertyenumeration(BaseEntityClass): + '''Entity ifcpropertyenumeration definition. + + :param name + :type name:ifclabel + + :param enumerationvalues + :type enumerationvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param unit + :type unit:ifcunit + ''' + def __init__( self , name,enumerationvalues,unit, ): + self.name = name + self.enumerationvalues = enumerationvalues + self.unit = unit + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def enumerationvalues(): + def fget( self ): + return self._enumerationvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument enumerationvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._enumerationvalues = LIST(value) + else: + self._enumerationvalues = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + def wr01(self): + eval_wr01_wr = (SIZEOF(None) == 0) + if not eval_wr01_wr: + raise AssertionError('Rule wr01 violated') + else: + return eval_wr01_wr + + +#################### + # ENTITY ifcrelconnectsports # +#################### +class ifcrelconnectsports(ifcrelconnects): + '''Entity ifcrelconnectsports definition. + + :param relatingport + :type relatingport:ifcport + + :param relatedport + :type relatedport:ifcport + + :param realizingelement + :type realizingelement:ifcelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingport,relatedport,realizingelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingport = relatingport + self.relatedport = relatedport + self.realizingelement = realizingelement + + @apply + def relatingport(): + def fget( self ): + return self._relatingport + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingport is mantatory and can not be set to None') + if not check_type(value,ifcport): + self._relatingport = ifcport(value) + else: + self._relatingport = value + return property(**locals()) + + @apply + def relatedport(): + def fget( self ): + return self._relatedport + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedport is mantatory and can not be set to None') + if not check_type(value,ifcport): + self._relatedport = ifcport(value) + else: + self._relatedport = value + return property(**locals()) + + @apply + def realizingelement(): + def fget( self ): + return self._realizingelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelement): + self._realizingelement = ifcelement(value) + else: + self._realizingelement = value + else: + self._realizingelement = value + return property(**locals()) + +#################### + # ENTITY ifcrectangulartrimmedsurface # +#################### +class ifcrectangulartrimmedsurface(ifcboundedsurface): + '''Entity ifcrectangulartrimmedsurface definition. + + :param basissurface + :type basissurface:ifcsurface + + :param u1 + :type u1:ifcparametervalue + + :param v1 + :type v1:ifcparametervalue + + :param u2 + :type u2:ifcparametervalue + + :param v2 + :type v2:ifcparametervalue + + :param usense + :type usense:BOOLEAN + + :param vsense + :type vsense:BOOLEAN + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , basissurface,u1,v1,u2,v2,usense,vsense, ): + ifcboundedsurface.__init__(self , ) + self.basissurface = basissurface + self.u1 = u1 + self.v1 = v1 + self.u2 = u2 + self.v2 = v2 + self.usense = usense + self.vsense = vsense + + @apply + def basissurface(): + def fget( self ): + return self._basissurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basissurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._basissurface = ifcsurface(value) + else: + self._basissurface = value + return property(**locals()) + + @apply + def u1(): + def fget( self ): + return self._u1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u1 is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._u1 = ifcparametervalue(value) + else: + self._u1 = value + return property(**locals()) + + @apply + def v1(): + def fget( self ): + return self._v1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v1 is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._v1 = ifcparametervalue(value) + else: + self._v1 = value + return property(**locals()) + + @apply + def u2(): + def fget( self ): + return self._u2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u2 is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._u2 = ifcparametervalue(value) + else: + self._u2 = value + return property(**locals()) + + @apply + def v2(): + def fget( self ): + return self._v2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v2 is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._v2 = ifcparametervalue(value) + else: + self._v2 = value + return property(**locals()) + + @apply + def usense(): + def fget( self ): + return self._usense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument usense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._usense = BOOLEAN(value) + else: + self._usense = value + return property(**locals()) + + @apply + def vsense(): + def fget( self ): + return self._vsense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vsense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._vsense = BOOLEAN(value) + else: + self._vsense = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.basissurface.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.u1 != self.u2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.v1 != self.v2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (((('IFC2X3.IFCELEMENTARYSURFACE' == TYPEOF(self.basissurface)) and ( not ('IFC2X3.IFCPLANE' == TYPEOF(self.basissurface)))) or ('IFC2X3.IFCSURFACEOFREVOLUTION' == TYPEOF(self.basissurface))) or (self.usense == (self.u2 > self.u1))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = (self.vsense == (self.v2 > self.v1)) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY ifcspatialstructureelement # +#################### +class ifcspatialstructureelement(ifcproduct): + '''Entity ifcspatialstructureelement definition. + + :param longname + :type longname:ifclabel + + :param compositiontype + :type compositiontype:ifcelementcompositionenum + + :param referenceselements + :type referenceselements:SET(0,None,'ifcrelreferencedinspatialstructure', scope = schema_scope) + + :param servicedbysystems + :type servicedbysystems:SET(0,None,'ifcrelservicesbuildings', scope = schema_scope) + + :param containselements + :type containselements:SET(0,None,'ifcrelcontainedinspatialstructure', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , longname,compositiontype, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.longname = longname + self.compositiontype = compositiontype + + @apply + def longname(): + def fget( self ): + return self._longname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._longname = ifclabel(value) + else: + self._longname = value + else: + self._longname = value + return property(**locals()) + + @apply + def compositiontype(): + def fget( self ): + return self._compositiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument compositiontype is mantatory and can not be set to None') + if not check_type(value,ifcelementcompositionenum): + self._compositiontype = ifcelementcompositionenum(value) + else: + self._compositiontype = value + return property(**locals()) + + @apply + def referenceselements(): + def fget( self ): + return self._referenceselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referenceselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def servicedbysystems(): + def fget( self ): + return self._servicedbysystems + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument servicedbysystems is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def containselements(): + def fget( self ): + return self._containselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr41(self): + eval_wr41_wr = (((HIINDEX(self.self.ifcobjectdefinition.self.decomposes) == 1) and ('IFC2X3.IFCRELAGGREGATES' == TYPEOF(self.self.ifcobjectdefinition.self.decomposes[1]))) and (('IFC2X3.IFCPROJECT' == TYPEOF(self.self.ifcobjectdefinition.self.decomposes[1].self.relatingobject)) or ('IFC2X3.IFCSPATIALSTRUCTUREELEMENT' == TYPEOF(self.self.ifcobjectdefinition.self.decomposes[1].self.relatingobject)))) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + +#################### + # ENTITY ifcbuilding # +#################### +class ifcbuilding(ifcspatialstructureelement): + '''Entity ifcbuilding definition. + + :param elevationofrefheight + :type elevationofrefheight:ifclengthmeasure + + :param elevationofterrain + :type elevationofterrain:ifclengthmeasure + + :param buildingaddress + :type buildingaddress:ifcpostaladdress + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , elevationofrefheight,elevationofterrain,buildingaddress, ): + ifcspatialstructureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , ) + self.elevationofrefheight = elevationofrefheight + self.elevationofterrain = elevationofterrain + self.buildingaddress = buildingaddress + + @apply + def elevationofrefheight(): + def fget( self ): + return self._elevationofrefheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._elevationofrefheight = ifclengthmeasure(value) + else: + self._elevationofrefheight = value + else: + self._elevationofrefheight = value + return property(**locals()) + + @apply + def elevationofterrain(): + def fget( self ): + return self._elevationofterrain + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._elevationofterrain = ifclengthmeasure(value) + else: + self._elevationofterrain = value + else: + self._elevationofterrain = value + return property(**locals()) + + @apply + def buildingaddress(): + def fget( self ): + return self._buildingaddress + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpostaladdress): + self._buildingaddress = ifcpostaladdress(value) + else: + self._buildingaddress = value + else: + self._buildingaddress = value + return property(**locals()) + +#################### + # ENTITY ifccolumn # +#################### +class ifccolumn(ifcbuildingelement): + '''Entity ifccolumn definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcextrudedareasolid # +#################### +class ifcextrudedareasolid(ifcsweptareasolid): + '''Entity ifcextrudedareasolid definition. + + :param extrudeddirection + :type extrudeddirection:ifcdirection + + :param depth + :type depth:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__sweptarea , inherited1__position , extrudeddirection,depth, ): + ifcsweptareasolid.__init__(self , inherited0__sweptarea , inherited1__position , ) + self.extrudeddirection = extrudeddirection + self.depth = depth + + @apply + def extrudeddirection(): + def fget( self ): + return self._extrudeddirection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extrudeddirection is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._extrudeddirection = ifcdirection(value) + else: + self._extrudeddirection = value + return property(**locals()) + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (ifcdotproduct((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,0,1]),self.self.extrudeddirection) != 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcmechanicalsteelmaterialproperties # +#################### +class ifcmechanicalsteelmaterialproperties(ifcmechanicalmaterialproperties): + '''Entity ifcmechanicalsteelmaterialproperties definition. + + :param yieldstress + :type yieldstress:ifcpressuremeasure + + :param ultimatestress + :type ultimatestress:ifcpressuremeasure + + :param ultimatestrain + :type ultimatestrain:ifcpositiveratiomeasure + + :param hardeningmodule + :type hardeningmodule:ifcmodulusofelasticitymeasure + + :param proportionalstress + :type proportionalstress:ifcpressuremeasure + + :param plasticstrain + :type plasticstrain:ifcpositiveratiomeasure + + :param relaxations + :type relaxations:SET(1,None,'ifcrelaxation', scope = schema_scope) + ''' + def __init__( self , inherited0__material , inherited1__dynamicviscosity , inherited2__youngmodulus , inherited3__shearmodulus , inherited4__poissonratio , inherited5__thermalexpansioncoefficient , yieldstress,ultimatestress,ultimatestrain,hardeningmodule,proportionalstress,plasticstrain,relaxations, ): + ifcmechanicalmaterialproperties.__init__(self , inherited0__material , inherited1__dynamicviscosity , inherited2__youngmodulus , inherited3__shearmodulus , inherited4__poissonratio , inherited5__thermalexpansioncoefficient , ) + self.yieldstress = yieldstress + self.ultimatestress = ultimatestress + self.ultimatestrain = ultimatestrain + self.hardeningmodule = hardeningmodule + self.proportionalstress = proportionalstress + self.plasticstrain = plasticstrain + self.relaxations = relaxations + + @apply + def yieldstress(): + def fget( self ): + return self._yieldstress + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpressuremeasure): + self._yieldstress = ifcpressuremeasure(value) + else: + self._yieldstress = value + else: + self._yieldstress = value + return property(**locals()) + + @apply + def ultimatestress(): + def fget( self ): + return self._ultimatestress + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpressuremeasure): + self._ultimatestress = ifcpressuremeasure(value) + else: + self._ultimatestress = value + else: + self._ultimatestress = value + return property(**locals()) + + @apply + def ultimatestrain(): + def fget( self ): + return self._ultimatestrain + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._ultimatestrain = ifcpositiveratiomeasure(value) + else: + self._ultimatestrain = value + else: + self._ultimatestrain = value + return property(**locals()) + + @apply + def hardeningmodule(): + def fget( self ): + return self._hardeningmodule + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofelasticitymeasure): + self._hardeningmodule = ifcmodulusofelasticitymeasure(value) + else: + self._hardeningmodule = value + else: + self._hardeningmodule = value + return property(**locals()) + + @apply + def proportionalstress(): + def fget( self ): + return self._proportionalstress + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpressuremeasure): + self._proportionalstress = ifcpressuremeasure(value) + else: + self._proportionalstress = value + else: + self._proportionalstress = value + return property(**locals()) + + @apply + def plasticstrain(): + def fget( self ): + return self._plasticstrain + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._plasticstrain = ifcpositiveratiomeasure(value) + else: + self._plasticstrain = value + else: + self._plasticstrain = value + return property(**locals()) + + @apply + def relaxations(): + def fget( self ): + return self._relaxations + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcrelaxation', scope = schema_scope)): + self._relaxations = SET(value) + else: + self._relaxations = value + else: + self._relaxations = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (( not EXISTS(self.yieldstress)) or (self.yieldstress >= 0)) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = (( not EXISTS(self.ultimatestress)) or (self.ultimatestress >= 0)) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + def wr33(self): + eval_wr33_wr = (( not EXISTS(self.hardeningmodule)) or (self.hardeningmodule >= 0)) + if not eval_wr33_wr: + raise AssertionError('Rule wr33 violated') + else: + return eval_wr33_wr + + def wr34(self): + eval_wr34_wr = (( not EXISTS(self.proportionalstress)) or (self.proportionalstress >= 0)) + if not eval_wr34_wr: + raise AssertionError('Rule wr34 violated') + else: + return eval_wr34_wr + + +#################### + # ENTITY ifcfurnishingelementtype # +#################### +class ifcfurnishingelementtype(ifcelementtype): + '''Entity ifcfurnishingelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcsystemfurnitureelementtype # +#################### +class ifcsystemfurnitureelementtype(ifcfurnishingelementtype): + '''Entity ifcsystemfurnitureelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcfurnishingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcthermalmaterialproperties # +#################### +class ifcthermalmaterialproperties(ifcmaterialproperties): + '''Entity ifcthermalmaterialproperties definition. + + :param specificheatcapacity + :type specificheatcapacity:ifcspecificheatcapacitymeasure + + :param boilingpoint + :type boilingpoint:ifcthermodynamictemperaturemeasure + + :param freezingpoint + :type freezingpoint:ifcthermodynamictemperaturemeasure + + :param thermalconductivity + :type thermalconductivity:ifcthermalconductivitymeasure + ''' + def __init__( self , inherited0__material , specificheatcapacity,boilingpoint,freezingpoint,thermalconductivity, ): + ifcmaterialproperties.__init__(self , inherited0__material , ) + self.specificheatcapacity = specificheatcapacity + self.boilingpoint = boilingpoint + self.freezingpoint = freezingpoint + self.thermalconductivity = thermalconductivity + + @apply + def specificheatcapacity(): + def fget( self ): + return self._specificheatcapacity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcspecificheatcapacitymeasure): + self._specificheatcapacity = ifcspecificheatcapacitymeasure(value) + else: + self._specificheatcapacity = value + else: + self._specificheatcapacity = value + return property(**locals()) + + @apply + def boilingpoint(): + def fget( self ): + return self._boilingpoint + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._boilingpoint = ifcthermodynamictemperaturemeasure(value) + else: + self._boilingpoint = value + else: + self._boilingpoint = value + return property(**locals()) + + @apply + def freezingpoint(): + def fget( self ): + return self._freezingpoint + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._freezingpoint = ifcthermodynamictemperaturemeasure(value) + else: + self._freezingpoint = value + else: + self._freezingpoint = value + return property(**locals()) + + @apply + def thermalconductivity(): + def fget( self ): + return self._thermalconductivity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermalconductivitymeasure): + self._thermalconductivity = ifcthermalconductivitymeasure(value) + else: + self._thermalconductivity = value + else: + self._thermalconductivity = value + return property(**locals()) + +#################### + # ENTITY ifccsgprimitive3d # +#################### +class ifccsgprimitive3d(ifcgeometricrepresentationitem): + '''Entity ifccsgprimitive3d definition. + + :param position + :type position:ifcaxis2placement3d + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , position, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcrightcircularcylinder # +#################### +class ifcrightcircularcylinder(ifccsgprimitive3d): + '''Entity ifcrightcircularcylinder definition. + + :param height + :type height:ifcpositivelengthmeasure + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , height,radius, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.height = height + self.radius = radius + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._height = ifcpositivelengthmeasure(value) + else: + self._height = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifctextliteralwithextent # +#################### +class ifctextliteralwithextent(ifctextliteral): + '''Entity ifctextliteralwithextent definition. + + :param extent + :type extent:ifcplanarextent + + :param boxalignment + :type boxalignment:ifcboxalignment + ''' + def __init__( self , inherited0__literal , inherited1__placement , inherited2__path , extent,boxalignment, ): + ifctextliteral.__init__(self , inherited0__literal , inherited1__placement , inherited2__path , ) + self.extent = extent + self.boxalignment = boxalignment + + @apply + def extent(): + def fget( self ): + return self._extent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extent is mantatory and can not be set to None') + if not check_type(value,ifcplanarextent): + self._extent = ifcplanarextent(value) + else: + self._extent = value + return property(**locals()) + + @apply + def boxalignment(): + def fget( self ): + return self._boxalignment + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument boxalignment is mantatory and can not be set to None') + if not check_type(value,ifcboxalignment): + self._boxalignment = ifcboxalignment(value) + else: + self._boxalignment = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = ( not ('IFC2X3.IFCPLANARBOX' == TYPEOF(self.extent))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcconstraint # +#################### +class ifcconstraint(BaseEntityClass): + '''Entity ifcconstraint definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param constraintgrade + :type constraintgrade:ifcconstraintenum + + :param constraintsource + :type constraintsource:ifclabel + + :param creatingactor + :type creatingactor:ifcactorselect + + :param creationtime + :type creationtime:ifcdatetimeselect + + :param userdefinedgrade + :type userdefinedgrade:ifclabel + + :param classifiedas + :type classifiedas:SET(0,None,'ifcconstraintclassificationrelationship', scope = schema_scope) + + :param relatesconstraints + :type relatesconstraints:SET(0,None,'ifcconstraintrelationship', scope = schema_scope) + + :param isrelatedwith + :type isrelatedwith:SET(0,None,'ifcconstraintrelationship', scope = schema_scope) + + :param propertiesforconstraint + :type propertiesforconstraint:SET(0,None,'ifcpropertyconstraintrelationship', scope = schema_scope) + + :param aggregates + :type aggregates:SET(0,None,'ifcconstraintaggregationrelationship', scope = schema_scope) + + :param isaggregatedin + :type isaggregatedin:SET(0,None,'ifcconstraintaggregationrelationship', scope = schema_scope) + ''' + def __init__( self , name,description,constraintgrade,constraintsource,creatingactor,creationtime,userdefinedgrade, ): + self.name = name + self.description = description + self.constraintgrade = constraintgrade + self.constraintsource = constraintsource + self.creatingactor = creatingactor + self.creationtime = creationtime + self.userdefinedgrade = userdefinedgrade + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def constraintgrade(): + def fget( self ): + return self._constraintgrade + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constraintgrade is mantatory and can not be set to None') + if not check_type(value,ifcconstraintenum): + self._constraintgrade = ifcconstraintenum(value) + else: + self._constraintgrade = value + return property(**locals()) + + @apply + def constraintsource(): + def fget( self ): + return self._constraintsource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._constraintsource = ifclabel(value) + else: + self._constraintsource = value + else: + self._constraintsource = value + return property(**locals()) + + @apply + def creatingactor(): + def fget( self ): + return self._creatingactor + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._creatingactor = ifcactorselect(value) + else: + self._creatingactor = value + else: + self._creatingactor = value + return property(**locals()) + + @apply + def creationtime(): + def fget( self ): + return self._creationtime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._creationtime = ifcdatetimeselect(value) + else: + self._creationtime = value + else: + self._creationtime = value + return property(**locals()) + + @apply + def userdefinedgrade(): + def fget( self ): + return self._userdefinedgrade + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedgrade = ifclabel(value) + else: + self._userdefinedgrade = value + else: + self._userdefinedgrade = value + return property(**locals()) + + @apply + def classifiedas(): + def fget( self ): + return self._classifiedas + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument classifiedas is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def relatesconstraints(): + def fget( self ): + return self._relatesconstraints + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument relatesconstraints is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isrelatedwith(): + def fget( self ): + return self._isrelatedwith + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isrelatedwith is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def propertiesforconstraint(): + def fget( self ): + return self._propertiesforconstraint + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument propertiesforconstraint is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def aggregates(): + def fget( self ): + return self._aggregates + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument aggregates is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isaggregatedin(): + def fget( self ): + return self._isaggregatedin + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isaggregatedin is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr11(self): + eval_wr11_wr = ((self.constraintgrade != ifcconstraintenum.self.userdefined) or ((self.constraintgrade == ifcconstraintenum.self.userdefined) and EXISTS(self.self.ifcconstraint.self.userdefinedgrade))) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcobjective # +#################### +class ifcobjective(ifcconstraint): + '''Entity ifcobjective definition. + + :param benchmarkvalues + :type benchmarkvalues:ifcmetric + + :param resultvalues + :type resultvalues:ifcmetric + + :param objectivequalifier + :type objectivequalifier:ifcobjectiveenum + + :param userdefinedqualifier + :type userdefinedqualifier:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__constraintgrade , inherited3__constraintsource , inherited4__creatingactor , inherited5__creationtime , inherited6__userdefinedgrade , benchmarkvalues,resultvalues,objectivequalifier,userdefinedqualifier, ): + ifcconstraint.__init__(self , inherited0__name , inherited1__description , inherited2__constraintgrade , inherited3__constraintsource , inherited4__creatingactor , inherited5__creationtime , inherited6__userdefinedgrade , ) + self.benchmarkvalues = benchmarkvalues + self.resultvalues = resultvalues + self.objectivequalifier = objectivequalifier + self.userdefinedqualifier = userdefinedqualifier + + @apply + def benchmarkvalues(): + def fget( self ): + return self._benchmarkvalues + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmetric): + self._benchmarkvalues = ifcmetric(value) + else: + self._benchmarkvalues = value + else: + self._benchmarkvalues = value + return property(**locals()) + + @apply + def resultvalues(): + def fget( self ): + return self._resultvalues + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmetric): + self._resultvalues = ifcmetric(value) + else: + self._resultvalues = value + else: + self._resultvalues = value + return property(**locals()) + + @apply + def objectivequalifier(): + def fget( self ): + return self._objectivequalifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument objectivequalifier is mantatory and can not be set to None') + if not check_type(value,ifcobjectiveenum): + self._objectivequalifier = ifcobjectiveenum(value) + else: + self._objectivequalifier = value + return property(**locals()) + + @apply + def userdefinedqualifier(): + def fget( self ): + return self._userdefinedqualifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedqualifier = ifclabel(value) + else: + self._userdefinedqualifier = value + else: + self._userdefinedqualifier = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ((self.objectivequalifier != ifcobjectiveenum.self.userdefined) or ((self.objectivequalifier == ifcobjectiveenum.self.userdefined) and EXISTS(self.self.ifcobjective.self.userdefinedqualifier))) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcbuildingelementcomponent # +#################### +class ifcbuildingelementcomponent(ifcbuildingelement): + '''Entity ifcbuildingelementcomponent definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcreinforcingelement # +#################### +class ifcreinforcingelement(ifcbuildingelementcomponent): + '''Entity ifcreinforcingelement definition. + + :param steelgrade + :type steelgrade:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , steelgrade, ): + ifcbuildingelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.steelgrade = steelgrade + + @apply + def steelgrade(): + def fget( self ): + return self._steelgrade + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._steelgrade = ifclabel(value) + else: + self._steelgrade = value + else: + self._steelgrade = value + return property(**locals()) + +#################### + # ENTITY ifcreinforcingmesh # +#################### +class ifcreinforcingmesh(ifcreinforcingelement): + '''Entity ifcreinforcingmesh definition. + + :param meshlength + :type meshlength:ifcpositivelengthmeasure + + :param meshwidth + :type meshwidth:ifcpositivelengthmeasure + + :param longitudinalbarnominaldiameter + :type longitudinalbarnominaldiameter:ifcpositivelengthmeasure + + :param transversebarnominaldiameter + :type transversebarnominaldiameter:ifcpositivelengthmeasure + + :param longitudinalbarcrosssectionarea + :type longitudinalbarcrosssectionarea:ifcareameasure + + :param transversebarcrosssectionarea + :type transversebarcrosssectionarea:ifcareameasure + + :param longitudinalbarspacing + :type longitudinalbarspacing:ifcpositivelengthmeasure + + :param transversebarspacing + :type transversebarspacing:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , meshlength,meshwidth,longitudinalbarnominaldiameter,transversebarnominaldiameter,longitudinalbarcrosssectionarea,transversebarcrosssectionarea,longitudinalbarspacing,transversebarspacing, ): + ifcreinforcingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , ) + self.meshlength = meshlength + self.meshwidth = meshwidth + self.longitudinalbarnominaldiameter = longitudinalbarnominaldiameter + self.transversebarnominaldiameter = transversebarnominaldiameter + self.longitudinalbarcrosssectionarea = longitudinalbarcrosssectionarea + self.transversebarcrosssectionarea = transversebarcrosssectionarea + self.longitudinalbarspacing = longitudinalbarspacing + self.transversebarspacing = transversebarspacing + + @apply + def meshlength(): + def fget( self ): + return self._meshlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._meshlength = ifcpositivelengthmeasure(value) + else: + self._meshlength = value + else: + self._meshlength = value + return property(**locals()) + + @apply + def meshwidth(): + def fget( self ): + return self._meshwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._meshwidth = ifcpositivelengthmeasure(value) + else: + self._meshwidth = value + else: + self._meshwidth = value + return property(**locals()) + + @apply + def longitudinalbarnominaldiameter(): + def fget( self ): + return self._longitudinalbarnominaldiameter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument longitudinalbarnominaldiameter is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._longitudinalbarnominaldiameter = ifcpositivelengthmeasure(value) + else: + self._longitudinalbarnominaldiameter = value + return property(**locals()) + + @apply + def transversebarnominaldiameter(): + def fget( self ): + return self._transversebarnominaldiameter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transversebarnominaldiameter is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._transversebarnominaldiameter = ifcpositivelengthmeasure(value) + else: + self._transversebarnominaldiameter = value + return property(**locals()) + + @apply + def longitudinalbarcrosssectionarea(): + def fget( self ): + return self._longitudinalbarcrosssectionarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument longitudinalbarcrosssectionarea is mantatory and can not be set to None') + if not check_type(value,ifcareameasure): + self._longitudinalbarcrosssectionarea = ifcareameasure(value) + else: + self._longitudinalbarcrosssectionarea = value + return property(**locals()) + + @apply + def transversebarcrosssectionarea(): + def fget( self ): + return self._transversebarcrosssectionarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transversebarcrosssectionarea is mantatory and can not be set to None') + if not check_type(value,ifcareameasure): + self._transversebarcrosssectionarea = ifcareameasure(value) + else: + self._transversebarcrosssectionarea = value + return property(**locals()) + + @apply + def longitudinalbarspacing(): + def fget( self ): + return self._longitudinalbarspacing + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument longitudinalbarspacing is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._longitudinalbarspacing = ifcpositivelengthmeasure(value) + else: + self._longitudinalbarspacing = value + return property(**locals()) + + @apply + def transversebarspacing(): + def fget( self ): + return self._transversebarspacing + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transversebarspacing is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._transversebarspacing = ifcpositivelengthmeasure(value) + else: + self._transversebarspacing = value + return property(**locals()) + +#################### + # ENTITY ifctubebundletype # +#################### +class ifctubebundletype(ifcenergyconversiondevicetype): + '''Entity ifctubebundletype definition. + + :param predefinedtype + :type predefinedtype:ifctubebundletypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctubebundletypeenum): + self._predefinedtype = ifctubebundletypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifctubebundletypeenum.self.userdefined) or ((self.predefinedtype == ifctubebundletypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcdoorliningproperties # +#################### +class ifcdoorliningproperties(ifcpropertysetdefinition): + '''Entity ifcdoorliningproperties definition. + + :param liningdepth + :type liningdepth:ifcpositivelengthmeasure + + :param liningthickness + :type liningthickness:ifcpositivelengthmeasure + + :param thresholddepth + :type thresholddepth:ifcpositivelengthmeasure + + :param thresholdthickness + :type thresholdthickness:ifcpositivelengthmeasure + + :param transomthickness + :type transomthickness:ifcpositivelengthmeasure + + :param transomoffset + :type transomoffset:ifclengthmeasure + + :param liningoffset + :type liningoffset:ifclengthmeasure + + :param thresholdoffset + :type thresholdoffset:ifclengthmeasure + + :param casingthickness + :type casingthickness:ifcpositivelengthmeasure + + :param casingdepth + :type casingdepth:ifcpositivelengthmeasure + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , liningdepth,liningthickness,thresholddepth,thresholdthickness,transomthickness,transomoffset,liningoffset,thresholdoffset,casingthickness,casingdepth,shapeaspectstyle, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.liningdepth = liningdepth + self.liningthickness = liningthickness + self.thresholddepth = thresholddepth + self.thresholdthickness = thresholdthickness + self.transomthickness = transomthickness + self.transomoffset = transomoffset + self.liningoffset = liningoffset + self.thresholdoffset = thresholdoffset + self.casingthickness = casingthickness + self.casingdepth = casingdepth + self.shapeaspectstyle = shapeaspectstyle + + @apply + def liningdepth(): + def fget( self ): + return self._liningdepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._liningdepth = ifcpositivelengthmeasure(value) + else: + self._liningdepth = value + else: + self._liningdepth = value + return property(**locals()) + + @apply + def liningthickness(): + def fget( self ): + return self._liningthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._liningthickness = ifcpositivelengthmeasure(value) + else: + self._liningthickness = value + else: + self._liningthickness = value + return property(**locals()) + + @apply + def thresholddepth(): + def fget( self ): + return self._thresholddepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._thresholddepth = ifcpositivelengthmeasure(value) + else: + self._thresholddepth = value + else: + self._thresholddepth = value + return property(**locals()) + + @apply + def thresholdthickness(): + def fget( self ): + return self._thresholdthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._thresholdthickness = ifcpositivelengthmeasure(value) + else: + self._thresholdthickness = value + else: + self._thresholdthickness = value + return property(**locals()) + + @apply + def transomthickness(): + def fget( self ): + return self._transomthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._transomthickness = ifcpositivelengthmeasure(value) + else: + self._transomthickness = value + else: + self._transomthickness = value + return property(**locals()) + + @apply + def transomoffset(): + def fget( self ): + return self._transomoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._transomoffset = ifclengthmeasure(value) + else: + self._transomoffset = value + else: + self._transomoffset = value + return property(**locals()) + + @apply + def liningoffset(): + def fget( self ): + return self._liningoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._liningoffset = ifclengthmeasure(value) + else: + self._liningoffset = value + else: + self._liningoffset = value + return property(**locals()) + + @apply + def thresholdoffset(): + def fget( self ): + return self._thresholdoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._thresholdoffset = ifclengthmeasure(value) + else: + self._thresholdoffset = value + else: + self._thresholdoffset = value + return property(**locals()) + + @apply + def casingthickness(): + def fget( self ): + return self._casingthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._casingthickness = ifcpositivelengthmeasure(value) + else: + self._casingthickness = value + else: + self._casingthickness = value + return property(**locals()) + + @apply + def casingdepth(): + def fget( self ): + return self._casingdepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._casingdepth = ifcpositivelengthmeasure(value) + else: + self._casingdepth = value + else: + self._casingdepth = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = ( not (( not EXISTS(self.liningdepth)) and EXISTS(self.liningthickness))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = ( not (( not EXISTS(self.thresholddepth)) and EXISTS(self.thresholdthickness))) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + def wr33(self): + eval_wr33_wr = ((EXISTS(self.transomoffset) and EXISTS(self.transomthickness)) XOR (( not EXISTS(self.transomoffset)) and ( not EXISTS(self.transomthickness)))) + if not eval_wr33_wr: + raise AssertionError('Rule wr33 violated') + else: + return eval_wr33_wr + + def wr34(self): + eval_wr34_wr = ((EXISTS(self.casingdepth) and EXISTS(self.casingthickness)) XOR (( not EXISTS(self.casingdepth)) and ( not EXISTS(self.casingthickness)))) + if not eval_wr34_wr: + raise AssertionError('Rule wr34 violated') + else: + return eval_wr34_wr + + def wr35(self): + eval_wr35_wr = (EXISTS(self.self.ifcpropertysetdefinition.self.definestype[1]) and ('IFC2X3.IFCDOORSTYLE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1]))) + if not eval_wr35_wr: + raise AssertionError('Rule wr35 violated') + else: + return eval_wr35_wr + + +#################### + # ENTITY ifcstructuralmember # +#################### +class ifcstructuralmember(ifcstructuralitem): + '''Entity ifcstructuralmember definition. + + :param referenceselement + :type referenceselement:SET(0,None,'ifcrelconnectsstructuralelement', scope = schema_scope) + + :param connectedby + :type connectedby:SET(0,None,'ifcrelconnectsstructuralmember', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ): + ifcstructuralitem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + + @apply + def referenceselement(): + def fget( self ): + return self._referenceselement + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referenceselement is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def connectedby(): + def fget( self ): + return self._connectedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructuralsurfacemember # +#################### +class ifcstructuralsurfacemember(ifcstructuralmember): + '''Entity ifcstructuralsurfacemember definition. + + :param predefinedtype + :type predefinedtype:ifcstructuralsurfacetypeenum + + :param thickness + :type thickness:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , predefinedtype,thickness, ): + ifcstructuralmember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.predefinedtype = predefinedtype + self.thickness = thickness + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstructuralsurfacetypeenum): + self._predefinedtype = ifcstructuralsurfacetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def thickness(): + def fget( self ): + return self._thickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._thickness = ifcpositivelengthmeasure(value) + else: + self._thickness = value + else: + self._thickness = value + return property(**locals()) + +#################### + # ENTITY ifcedgecurve # +#################### +class ifcedgecurve(ifcedge): + '''Entity ifcedgecurve definition. + + :param edgegeometry + :type edgegeometry:ifccurve + + :param samesense + :type samesense:BOOLEAN + ''' + def __init__( self , inherited0__edgestart , inherited1__edgeend , edgegeometry,samesense, ): + ifcedge.__init__(self , inherited0__edgestart , inherited1__edgeend , ) + self.edgegeometry = edgegeometry + self.samesense = samesense + + @apply + def edgegeometry(): + def fget( self ): + return self._edgegeometry + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgegeometry is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._edgegeometry = ifccurve(value) + else: + self._edgegeometry = value + return property(**locals()) + + @apply + def samesense(): + def fget( self ): + return self._samesense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument samesense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._samesense = BOOLEAN(value) + else: + self._samesense = value + return property(**locals()) + +#################### + # ENTITY ifcflowtreatmentdevice # +#################### +class ifcflowtreatmentdevice(ifcdistributionflowelement): + '''Entity ifcflowtreatmentdevice definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifclightfixturetype # +#################### +class ifclightfixturetype(ifcflowterminaltype): + '''Entity ifclightfixturetype definition. + + :param predefinedtype + :type predefinedtype:ifclightfixturetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifclightfixturetypeenum): + self._predefinedtype = ifclightfixturetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcline # +#################### +class ifcline(ifccurve): + '''Entity ifcline definition. + + :param pnt + :type pnt:ifccartesianpoint + + :param dir + :type dir:ifcvector + ''' + def __init__( self , pnt,dir, ): + ifccurve.__init__(self , ) + self.pnt = pnt + self.dir = dir + + @apply + def pnt(): + def fget( self ): + return self._pnt + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pnt is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._pnt = ifccartesianpoint(value) + else: + self._pnt = value + return property(**locals()) + + @apply + def dir(): + def fget( self ): + return self._dir + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dir is mantatory and can not be set to None') + if not check_type(value,ifcvector): + self._dir = ifcvector(value) + else: + self._dir = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.dir.self.dim == self.pnt.self.dim) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcconic # +#################### +class ifcconic(ifccurve): + '''Entity ifcconic definition. + + :param position + :type position:ifcaxis2placement + ''' + def __init__( self , position, ): + ifccurve.__init__(self , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._position = ifcaxis2placement(value) + else: + self._position = value + return property(**locals()) + +#################### + # ENTITY ifcrelconnectsporttoelement # +#################### +class ifcrelconnectsporttoelement(ifcrelconnects): + '''Entity ifcrelconnectsporttoelement definition. + + :param relatingport + :type relatingport:ifcport + + :param relatedelement + :type relatedelement:ifcelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingport,relatedelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingport = relatingport + self.relatedelement = relatedelement + + @apply + def relatingport(): + def fget( self ): + return self._relatingport + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingport is mantatory and can not be set to None') + if not check_type(value,ifcport): + self._relatingport = ifcport(value) + else: + self._relatingport = value + return property(**locals()) + + @apply + def relatedelement(): + def fget( self ): + return self._relatedelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatedelement = ifcelement(value) + else: + self._relatedelement = value + return property(**locals()) + +#################### + # ENTITY ifcequipmentstandard # +#################### +class ifcequipmentstandard(ifccontrol): + '''Entity ifcequipmentstandard definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + +#################### + # ENTITY ifcflowmetertype # +#################### +class ifcflowmetertype(ifcflowcontrollertype): + '''Entity ifcflowmetertype definition. + + :param predefinedtype + :type predefinedtype:ifcflowmetertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcflowmetertypeenum): + self._predefinedtype = ifcflowmetertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcflowmetertypeenum.self.userdefined) or ((self.predefinedtype == ifcflowmetertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcprojectorderrecord # +#################### +class ifcprojectorderrecord(ifccontrol): + '''Entity ifcprojectorderrecord definition. + + :param records + :type records:LIST(1,None,'ifcrelassignstoprojectorder', scope = schema_scope) + + :param predefinedtype + :type predefinedtype:ifcprojectorderrecordtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , records,predefinedtype, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.records = records + self.predefinedtype = predefinedtype + + @apply + def records(): + def fget( self ): + return self._records + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument records is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcrelassignstoprojectorder', scope = schema_scope)): + self._records = LIST(value) + else: + self._records = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcprojectorderrecordtypeenum): + self._predefinedtype = ifcprojectorderrecordtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcquantityarea # +#################### +class ifcquantityarea(ifcphysicalsimplequantity): + '''Entity ifcquantityarea definition. + + :param areavalue + :type areavalue:ifcareameasure + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , areavalue, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.areavalue = areavalue + + @apply + def areavalue(): + def fget( self ): + return self._areavalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument areavalue is mantatory and can not be set to None') + if not check_type(value,ifcareameasure): + self._areavalue = ifcareameasure(value) + else: + self._areavalue = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.areaunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.areavalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcworkcontrol # +#################### +class ifcworkcontrol(ifccontrol): + '''Entity ifcworkcontrol definition. + + :param identifier + :type identifier:ifcidentifier + + :param creationdate + :type creationdate:ifcdatetimeselect + + :param creators + :type creators:SET(1,None,'ifcperson', scope = schema_scope) + + :param purpose + :type purpose:ifclabel + + :param duration + :type duration:ifctimemeasure + + :param totalfloat + :type totalfloat:ifctimemeasure + + :param starttime + :type starttime:ifcdatetimeselect + + :param finishtime + :type finishtime:ifcdatetimeselect + + :param workcontroltype + :type workcontroltype:ifcworkcontroltypeenum + + :param userdefinedcontroltype + :type userdefinedcontroltype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , identifier,creationdate,creators,purpose,duration,totalfloat,starttime,finishtime,workcontroltype,userdefinedcontroltype, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.identifier = identifier + self.creationdate = creationdate + self.creators = creators + self.purpose = purpose + self.duration = duration + self.totalfloat = totalfloat + self.starttime = starttime + self.finishtime = finishtime + self.workcontroltype = workcontroltype + self.userdefinedcontroltype = userdefinedcontroltype + + @apply + def identifier(): + def fget( self ): + return self._identifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument identifier is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._identifier = ifcidentifier(value) + else: + self._identifier = value + return property(**locals()) + + @apply + def creationdate(): + def fget( self ): + return self._creationdate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument creationdate is mantatory and can not be set to None') + if not check_type(value,ifcdatetimeselect): + self._creationdate = ifcdatetimeselect(value) + else: + self._creationdate = value + return property(**locals()) + + @apply + def creators(): + def fget( self ): + return self._creators + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcperson', scope = schema_scope)): + self._creators = SET(value) + else: + self._creators = value + else: + self._creators = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._purpose = ifclabel(value) + else: + self._purpose = value + else: + self._purpose = value + return property(**locals()) + + @apply + def duration(): + def fget( self ): + return self._duration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimemeasure): + self._duration = ifctimemeasure(value) + else: + self._duration = value + else: + self._duration = value + return property(**locals()) + + @apply + def totalfloat(): + def fget( self ): + return self._totalfloat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimemeasure): + self._totalfloat = ifctimemeasure(value) + else: + self._totalfloat = value + else: + self._totalfloat = value + return property(**locals()) + + @apply + def starttime(): + def fget( self ): + return self._starttime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument starttime is mantatory and can not be set to None') + if not check_type(value,ifcdatetimeselect): + self._starttime = ifcdatetimeselect(value) + else: + self._starttime = value + return property(**locals()) + + @apply + def finishtime(): + def fget( self ): + return self._finishtime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._finishtime = ifcdatetimeselect(value) + else: + self._finishtime = value + else: + self._finishtime = value + return property(**locals()) + + @apply + def workcontroltype(): + def fget( self ): + return self._workcontroltype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcworkcontroltypeenum): + self._workcontroltype = ifcworkcontroltypeenum(value) + else: + self._workcontroltype = value + else: + self._workcontroltype = value + return property(**locals()) + + @apply + def userdefinedcontroltype(): + def fget( self ): + return self._userdefinedcontroltype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedcontroltype = ifclabel(value) + else: + self._userdefinedcontroltype = value + else: + self._userdefinedcontroltype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.workcontroltype != ifcworkcontroltypeenum.self.userdefined) or ((self.workcontroltype == ifcworkcontroltypeenum.self.userdefined) and EXISTS(self.self.ifcworkcontrol.self.userdefinedcontroltype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcworkplan # +#################### +class ifcworkplan(ifcworkcontrol): + '''Entity ifcworkplan definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identifier , inherited6__creationdate , inherited7__creators , inherited8__purpose , inherited9__duration , inherited10__totalfloat , inherited11__starttime , inherited12__finishtime , inherited13__workcontroltype , inherited14__userdefinedcontroltype , ): + ifcworkcontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identifier , inherited6__creationdate , inherited7__creators , inherited8__purpose , inherited9__duration , inherited10__totalfloat , inherited11__starttime , inherited12__finishtime , inherited13__workcontroltype , inherited14__userdefinedcontroltype , ) + +#################### + # ENTITY ifcenergyconversiondevice # +#################### +class ifcenergyconversiondevice(ifcdistributionflowelement): + '''Entity ifcenergyconversiondevice definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcpropertydependencyrelationship # +#################### +class ifcpropertydependencyrelationship(BaseEntityClass): + '''Entity ifcpropertydependencyrelationship definition. + + :param dependingproperty + :type dependingproperty:ifcproperty + + :param dependantproperty + :type dependantproperty:ifcproperty + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param expression + :type expression:ifctext + ''' + def __init__( self , dependingproperty,dependantproperty,name,description,expression, ): + self.dependingproperty = dependingproperty + self.dependantproperty = dependantproperty + self.name = name + self.description = description + self.expression = expression + + @apply + def dependingproperty(): + def fget( self ): + return self._dependingproperty + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dependingproperty is mantatory and can not be set to None') + if not check_type(value,ifcproperty): + self._dependingproperty = ifcproperty(value) + else: + self._dependingproperty = value + return property(**locals()) + + @apply + def dependantproperty(): + def fget( self ): + return self._dependantproperty + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dependantproperty is mantatory and can not be set to None') + if not check_type(value,ifcproperty): + self._dependantproperty = ifcproperty(value) + else: + self._dependantproperty = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def expression(): + def fget( self ): + return self._expression + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._expression = ifctext(value) + else: + self._expression = value + else: + self._expression = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.dependingproperty != self.dependantproperty) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelspaceboundary # +#################### +class ifcrelspaceboundary(ifcrelconnects): + '''Entity ifcrelspaceboundary definition. + + :param relatingspace + :type relatingspace:ifcspace + + :param relatedbuildingelement + :type relatedbuildingelement:ifcelement + + :param connectiongeometry + :type connectiongeometry:ifcconnectiongeometry + + :param physicalorvirtualboundary + :type physicalorvirtualboundary:ifcphysicalorvirtualenum + + :param internalorexternalboundary + :type internalorexternalboundary:ifcinternalorexternalenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingspace,relatedbuildingelement,connectiongeometry,physicalorvirtualboundary,internalorexternalboundary, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingspace = relatingspace + self.relatedbuildingelement = relatedbuildingelement + self.connectiongeometry = connectiongeometry + self.physicalorvirtualboundary = physicalorvirtualboundary + self.internalorexternalboundary = internalorexternalboundary + + @apply + def relatingspace(): + def fget( self ): + return self._relatingspace + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingspace is mantatory and can not be set to None') + if not check_type(value,ifcspace): + self._relatingspace = ifcspace(value) + else: + self._relatingspace = value + return property(**locals()) + + @apply + def relatedbuildingelement(): + def fget( self ): + return self._relatedbuildingelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelement): + self._relatedbuildingelement = ifcelement(value) + else: + self._relatedbuildingelement = value + else: + self._relatedbuildingelement = value + return property(**locals()) + + @apply + def connectiongeometry(): + def fget( self ): + return self._connectiongeometry + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcconnectiongeometry): + self._connectiongeometry = ifcconnectiongeometry(value) + else: + self._connectiongeometry = value + else: + self._connectiongeometry = value + return property(**locals()) + + @apply + def physicalorvirtualboundary(): + def fget( self ): + return self._physicalorvirtualboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument physicalorvirtualboundary is mantatory and can not be set to None') + if not check_type(value,ifcphysicalorvirtualenum): + self._physicalorvirtualboundary = ifcphysicalorvirtualenum(value) + else: + self._physicalorvirtualboundary = value + return property(**locals()) + + @apply + def internalorexternalboundary(): + def fget( self ): + return self._internalorexternalboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument internalorexternalboundary is mantatory and can not be set to None') + if not check_type(value,ifcinternalorexternalenum): + self._internalorexternalboundary = ifcinternalorexternalenum(value) + else: + self._internalorexternalboundary = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((((self.physicalorvirtualboundary == ifcphysicalorvirtualenum.self.physical) and (EXISTS(self.relatedbuildingelement) and ( not ('IFC2X3.IFCVIRTUALELEMENT' == TYPEOF(self.relatedbuildingelement))))) or ((self.physicalorvirtualboundary == ifcphysicalorvirtualenum.self.virtual) and (( not EXISTS(self.relatedbuildingelement)) or ('IFC2X3.IFCVIRTUALELEMENT' == TYPEOF(self.relatedbuildingelement))))) or (self.physicalorvirtualboundary == ifcphysicalorvirtualenum.self.notdefined)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcappliedvalue # +#################### +class ifcappliedvalue(BaseEntityClass): + '''Entity ifcappliedvalue definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param appliedvalue + :type appliedvalue:ifcappliedvalueselect + + :param unitbasis + :type unitbasis:ifcmeasurewithunit + + :param applicabledate + :type applicabledate:ifcdatetimeselect + + :param fixeduntildate + :type fixeduntildate:ifcdatetimeselect + + :param valuesreferenced + :type valuesreferenced:SET(0,None,'ifcreferencesvaluedocument', scope = schema_scope) + + :param valueofcomponents + :type valueofcomponents:SET(0,None,'ifcappliedvaluerelationship', scope = schema_scope) + + :param iscomponentin + :type iscomponentin:SET(0,None,'ifcappliedvaluerelationship', scope = schema_scope) + ''' + def __init__( self , name,description,appliedvalue,unitbasis,applicabledate,fixeduntildate, ): + self.name = name + self.description = description + self.appliedvalue = appliedvalue + self.unitbasis = unitbasis + self.applicabledate = applicabledate + self.fixeduntildate = fixeduntildate + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def appliedvalue(): + def fget( self ): + return self._appliedvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcappliedvalueselect): + self._appliedvalue = ifcappliedvalueselect(value) + else: + self._appliedvalue = value + else: + self._appliedvalue = value + return property(**locals()) + + @apply + def unitbasis(): + def fget( self ): + return self._unitbasis + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmeasurewithunit): + self._unitbasis = ifcmeasurewithunit(value) + else: + self._unitbasis = value + else: + self._unitbasis = value + return property(**locals()) + + @apply + def applicabledate(): + def fget( self ): + return self._applicabledate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._applicabledate = ifcdatetimeselect(value) + else: + self._applicabledate = value + else: + self._applicabledate = value + return property(**locals()) + + @apply + def fixeduntildate(): + def fget( self ): + return self._fixeduntildate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._fixeduntildate = ifcdatetimeselect(value) + else: + self._fixeduntildate = value + else: + self._fixeduntildate = value + return property(**locals()) + + @apply + def valuesreferenced(): + def fget( self ): + return self._valuesreferenced + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument valuesreferenced is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def valueofcomponents(): + def fget( self ): + return self._valueofcomponents + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument valueofcomponents is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def iscomponentin(): + def fget( self ): + return self._iscomponentin + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument iscomponentin is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (EXISTS(self.appliedvalue) or EXISTS(self.valueofcomponents)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcenvironmentalimpactvalue # +#################### +class ifcenvironmentalimpactvalue(ifcappliedvalue): + '''Entity ifcenvironmentalimpactvalue definition. + + :param impacttype + :type impacttype:ifclabel + + :param category + :type category:ifcenvironmentalimpactcategoryenum + + :param userdefinedcategory + :type userdefinedcategory:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__appliedvalue , inherited3__unitbasis , inherited4__applicabledate , inherited5__fixeduntildate , impacttype,category,userdefinedcategory, ): + ifcappliedvalue.__init__(self , inherited0__name , inherited1__description , inherited2__appliedvalue , inherited3__unitbasis , inherited4__applicabledate , inherited5__fixeduntildate , ) + self.impacttype = impacttype + self.category = category + self.userdefinedcategory = userdefinedcategory + + @apply + def impacttype(): + def fget( self ): + return self._impacttype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument impacttype is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._impacttype = ifclabel(value) + else: + self._impacttype = value + return property(**locals()) + + @apply + def category(): + def fget( self ): + return self._category + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument category is mantatory and can not be set to None') + if not check_type(value,ifcenvironmentalimpactcategoryenum): + self._category = ifcenvironmentalimpactcategoryenum(value) + else: + self._category = value + return property(**locals()) + + @apply + def userdefinedcategory(): + def fget( self ): + return self._userdefinedcategory + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedcategory = ifclabel(value) + else: + self._userdefinedcategory = value + else: + self._userdefinedcategory = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.category != ifcenvironmentalimpactcategoryenum.self.userdefined) or ((self.category == ifcenvironmentalimpactcategoryenum.self.userdefined) and EXISTS(self.self.ifcenvironmentalimpactvalue.self.userdefinedcategory))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcfillareastylehatching # +#################### +class ifcfillareastylehatching(ifcgeometricrepresentationitem): + '''Entity ifcfillareastylehatching definition. + + :param hatchlineappearance + :type hatchlineappearance:ifccurvestyle + + :param startofnexthatchline + :type startofnexthatchline:ifchatchlinedistanceselect + + :param pointofreferencehatchline + :type pointofreferencehatchline:ifccartesianpoint + + :param patternstart + :type patternstart:ifccartesianpoint + + :param hatchlineangle + :type hatchlineangle:ifcplaneanglemeasure + ''' + def __init__( self , hatchlineappearance,startofnexthatchline,pointofreferencehatchline,patternstart,hatchlineangle, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.hatchlineappearance = hatchlineappearance + self.startofnexthatchline = startofnexthatchline + self.pointofreferencehatchline = pointofreferencehatchline + self.patternstart = patternstart + self.hatchlineangle = hatchlineangle + + @apply + def hatchlineappearance(): + def fget( self ): + return self._hatchlineappearance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hatchlineappearance is mantatory and can not be set to None') + if not check_type(value,ifccurvestyle): + self._hatchlineappearance = ifccurvestyle(value) + else: + self._hatchlineappearance = value + return property(**locals()) + + @apply + def startofnexthatchline(): + def fget( self ): + return self._startofnexthatchline + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument startofnexthatchline is mantatory and can not be set to None') + if not check_type(value,ifchatchlinedistanceselect): + self._startofnexthatchline = ifchatchlinedistanceselect(value) + else: + self._startofnexthatchline = value + return property(**locals()) + + @apply + def pointofreferencehatchline(): + def fget( self ): + return self._pointofreferencehatchline + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccartesianpoint): + self._pointofreferencehatchline = ifccartesianpoint(value) + else: + self._pointofreferencehatchline = value + else: + self._pointofreferencehatchline = value + return property(**locals()) + + @apply + def patternstart(): + def fget( self ): + return self._patternstart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccartesianpoint): + self._patternstart = ifccartesianpoint(value) + else: + self._patternstart = value + else: + self._patternstart = value + return property(**locals()) + + @apply + def hatchlineangle(): + def fget( self ): + return self._hatchlineangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hatchlineangle is mantatory and can not be set to None') + if not check_type(value,ifcplaneanglemeasure): + self._hatchlineangle = ifcplaneanglemeasure(value) + else: + self._hatchlineangle = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ( not ('IFC2X3.IFCTWODIRECTIONREPEATFACTOR' == TYPEOF(self.startofnexthatchline))) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (( not EXISTS(self.patternstart)) or (self.patternstart.self.dim == 2)) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + def wr23(self): + eval_wr23_wr = (( not EXISTS(self.pointofreferencehatchline)) or (self.pointofreferencehatchline.self.dim == 2)) + if not eval_wr23_wr: + raise AssertionError('Rule wr23 violated') + else: + return eval_wr23_wr + + +#################### + # ENTITY ifcheatexchangertype # +#################### +class ifcheatexchangertype(ifcenergyconversiondevicetype): + '''Entity ifcheatexchangertype definition. + + :param predefinedtype + :type predefinedtype:ifcheatexchangertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcheatexchangertypeenum): + self._predefinedtype = ifcheatexchangertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcheatexchangertypeenum.self.userdefined) or ((self.predefinedtype == ifcheatexchangertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifconedirectionrepeatfactor # +#################### +class ifconedirectionrepeatfactor(ifcgeometricrepresentationitem): + '''Entity ifconedirectionrepeatfactor definition. + + :param repeatfactor + :type repeatfactor:ifcvector + ''' + def __init__( self , repeatfactor, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.repeatfactor = repeatfactor + + @apply + def repeatfactor(): + def fget( self ): + return self._repeatfactor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument repeatfactor is mantatory and can not be set to None') + if not check_type(value,ifcvector): + self._repeatfactor = ifcvector(value) + else: + self._repeatfactor = value + return property(**locals()) + +#################### + # ENTITY ifcpolygonalboundedhalfspace # +#################### +class ifcpolygonalboundedhalfspace(ifchalfspacesolid): + '''Entity ifcpolygonalboundedhalfspace definition. + + :param position + :type position:ifcaxis2placement3d + + :param polygonalboundary + :type polygonalboundary:ifcboundedcurve + ''' + def __init__( self , inherited0__basesurface , inherited1__agreementflag , position,polygonalboundary, ): + ifchalfspacesolid.__init__(self , inherited0__basesurface , inherited1__agreementflag , ) + self.position = position + self.polygonalboundary = polygonalboundary + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def polygonalboundary(): + def fget( self ): + return self._polygonalboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument polygonalboundary is mantatory and can not be set to None') + if not check_type(value,ifcboundedcurve): + self._polygonalboundary = ifcboundedcurve(value) + else: + self._polygonalboundary = value + return property(**locals()) + def wr41(self): + eval_wr41_wr = (self.polygonalboundary.self.dim == 2) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + def wr42(self): + eval_wr42_wr = (SIZEOF(TYPEOF(self.polygonalboundary) * ['IFC2X3.IFCPOLYLINE','IFC2X3.IFCCOMPOSITECURVE']) == 1) + if not eval_wr42_wr: + raise AssertionError('Rule wr42 violated') + else: + return eval_wr42_wr + + +#################### + # ENTITY ifccondensertype # +#################### +class ifccondensertype(ifcenergyconversiondevicetype): + '''Entity ifccondensertype definition. + + :param predefinedtype + :type predefinedtype:ifccondensertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccondensertypeenum): + self._predefinedtype = ifccondensertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifccondensertypeenum.self.userdefined) or ((self.predefinedtype == ifccondensertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcslab # +#################### +class ifcslab(ifcbuildingelement): + '''Entity ifcslab definition. + + :param predefinedtype + :type predefinedtype:ifcslabtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcslabtypeenum): + self._predefinedtype = ifcslabtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def wr61(self): + eval_wr61_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcslabtypeenum.self.userdefined)) or ((self.predefinedtype == ifcslabtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_wr61_wr: + raise AssertionError('Rule wr61 violated') + else: + return eval_wr61_wr + + +#################### + # ENTITY ifccoolingtowertype # +#################### +class ifccoolingtowertype(ifcenergyconversiondevicetype): + '''Entity ifccoolingtowertype definition. + + :param predefinedtype + :type predefinedtype:ifccoolingtowertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccoolingtowertypeenum): + self._predefinedtype = ifccoolingtowertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifccoolingtowertypeenum.self.userdefined) or ((self.predefinedtype == ifccoolingtowertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcpredefinedtextfont # +#################### +class ifcpredefinedtextfont(ifcpredefineditem): + '''Entity ifcpredefinedtextfont definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefineditem.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcdraughtingpredefinedtextfont # +#################### +class ifcdraughtingpredefinedtextfont(ifcpredefinedtextfont): + '''Entity ifcdraughtingpredefinedtextfont definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefinedtextfont.__init__(self , inherited0__name , ) + def wr31(self): + eval_wr31_wr = (self.self.ifcpredefineditem.self.name == ['ISO 3098-1 font A','ISO 3098-1 font B']) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcannotationcurveoccurrence # +#################### +class ifcannotationcurveoccurrence(ifcannotationoccurrence): + '''Entity ifcannotationcurveoccurrence definition. + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , ): + ifcannotationoccurrence.__init__(self , inherited0__item , inherited1__styles , inherited2__name , ) + def wr31(self): + eval_wr31_wr = (( not EXISTS(self.self.ifcstyleditem.self.item)) or ('IFC2X3.IFCCURVE' == TYPEOF(self.self.ifcstyleditem.self.item))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcdimensioncurve # +#################### +class ifcdimensioncurve(ifcannotationcurveoccurrence): + '''Entity ifcdimensioncurve definition. + + :param annotatedbysymbols + :type annotatedbysymbols:SET(0,2,'ifcterminatorsymbol', scope = schema_scope) + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , ): + ifcannotationcurveoccurrence.__init__(self , inherited0__item , inherited1__styles , inherited2__name , ) + + @apply + def annotatedbysymbols(): + def fget( self ): + return self._annotatedbysymbols + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument annotatedbysymbols is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr51(self): + eval_wr51_wr = (SIZEOF(USEDIN(self,'IFC2X3.IFCDRAUGHTINGCALLOUT.CONTENTS')) >= 1) + if not eval_wr51_wr: + raise AssertionError('Rule wr51 violated') + else: + return eval_wr51_wr + + def wr52(self): + eval_wr52_wr = ((SIZEOF(None) <= 1) and (SIZEOF(None) <= 1)) + if not eval_wr52_wr: + raise AssertionError('Rule wr52 violated') + else: + return eval_wr52_wr + + def wr53(self): + eval_wr53_wr = (SIZEOF(None) == 0) + if not eval_wr53_wr: + raise AssertionError('Rule wr53 violated') + else: + return eval_wr53_wr + + +#################### + # ENTITY ifcclassification # +#################### +class ifcclassification(BaseEntityClass): + '''Entity ifcclassification definition. + + :param source + :type source:ifclabel + + :param edition + :type edition:ifclabel + + :param editiondate + :type editiondate:ifccalendardate + + :param name + :type name:ifclabel + + :param contains + :type contains:SET(0,None,'ifcclassificationitem', scope = schema_scope) + ''' + def __init__( self , source,edition,editiondate,name, ): + self.source = source + self.edition = edition + self.editiondate = editiondate + self.name = name + + @apply + def source(): + def fget( self ): + return self._source + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument source is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._source = ifclabel(value) + else: + self._source = value + return property(**locals()) + + @apply + def edition(): + def fget( self ): + return self._edition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edition is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._edition = ifclabel(value) + else: + self._edition = value + return property(**locals()) + + @apply + def editiondate(): + def fget( self ): + return self._editiondate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccalendardate): + self._editiondate = ifccalendardate(value) + else: + self._editiondate = value + else: + self._editiondate = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def contains(): + def fget( self ): + return self._contains + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument contains is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcdraughtingcalloutrelationship # +#################### +class ifcdraughtingcalloutrelationship(BaseEntityClass): + '''Entity ifcdraughtingcalloutrelationship definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param relatingdraughtingcallout + :type relatingdraughtingcallout:ifcdraughtingcallout + + :param relateddraughtingcallout + :type relateddraughtingcallout:ifcdraughtingcallout + ''' + def __init__( self , name,description,relatingdraughtingcallout,relateddraughtingcallout, ): + self.name = name + self.description = description + self.relatingdraughtingcallout = relatingdraughtingcallout + self.relateddraughtingcallout = relateddraughtingcallout + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relatingdraughtingcallout(): + def fget( self ): + return self._relatingdraughtingcallout + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingdraughtingcallout is mantatory and can not be set to None') + if not check_type(value,ifcdraughtingcallout): + self._relatingdraughtingcallout = ifcdraughtingcallout(value) + else: + self._relatingdraughtingcallout = value + return property(**locals()) + + @apply + def relateddraughtingcallout(): + def fget( self ): + return self._relateddraughtingcallout + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relateddraughtingcallout is mantatory and can not be set to None') + if not check_type(value,ifcdraughtingcallout): + self._relateddraughtingcallout = ifcdraughtingcallout(value) + else: + self._relateddraughtingcallout = value + return property(**locals()) + +#################### + # ENTITY ifcgridaxis # +#################### +class ifcgridaxis(BaseEntityClass): + '''Entity ifcgridaxis definition. + + :param axistag + :type axistag:ifclabel + + :param axiscurve + :type axiscurve:ifccurve + + :param samesense + :type samesense:ifcboolean + + :param partofw + :type partofw:SET(0,1,'ifcgrid', scope = schema_scope) + + :param partofv + :type partofv:SET(0,1,'ifcgrid', scope = schema_scope) + + :param partofu + :type partofu:SET(0,1,'ifcgrid', scope = schema_scope) + + :param hasintersections + :type hasintersections:SET(0,None,'ifcvirtualgridintersection', scope = schema_scope) + ''' + def __init__( self , axistag,axiscurve,samesense, ): + self.axistag = axistag + self.axiscurve = axiscurve + self.samesense = samesense + + @apply + def axistag(): + def fget( self ): + return self._axistag + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._axistag = ifclabel(value) + else: + self._axistag = value + else: + self._axistag = value + return property(**locals()) + + @apply + def axiscurve(): + def fget( self ): + return self._axiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._axiscurve = ifccurve(value) + else: + self._axiscurve = value + return property(**locals()) + + @apply + def samesense(): + def fget( self ): + return self._samesense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument samesense is mantatory and can not be set to None') + if not check_type(value,ifcboolean): + self._samesense = ifcboolean(value) + else: + self._samesense = value + return property(**locals()) + + @apply + def partofw(): + def fget( self ): + return self._partofw + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofw is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def partofv(): + def fget( self ): + return self._partofv + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofv is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def partofu(): + def fget( self ): + return self._partofu + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofu is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasintersections(): + def fget( self ): + return self._hasintersections + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasintersections is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.axiscurve.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(self.partofu) == 1) XOR (SIZEOF(self.partofv) == 1) XOR (SIZEOF(self.partofw) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifctransportelement # +#################### +class ifctransportelement(ifcelement): + '''Entity ifctransportelement definition. + + :param operationtype + :type operationtype:ifctransportelementtypeenum + + :param capacitybyweight + :type capacitybyweight:ifcmassmeasure + + :param capacitybynumber + :type capacitybynumber:ifccountmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , operationtype,capacitybyweight,capacitybynumber, ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.operationtype = operationtype + self.capacitybyweight = capacitybyweight + self.capacitybynumber = capacitybynumber + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctransportelementtypeenum): + self._operationtype = ifctransportelementtypeenum(value) + else: + self._operationtype = value + else: + self._operationtype = value + return property(**locals()) + + @apply + def capacitybyweight(): + def fget( self ): + return self._capacitybyweight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmassmeasure): + self._capacitybyweight = ifcmassmeasure(value) + else: + self._capacitybyweight = value + else: + self._capacitybyweight = value + return property(**locals()) + + @apply + def capacitybynumber(): + def fget( self ): + return self._capacitybynumber + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccountmeasure): + self._capacitybynumber = ifccountmeasure(value) + else: + self._capacitybynumber = value + else: + self._capacitybynumber = value + return property(**locals()) + +#################### + # ENTITY ifcderivedunit # +#################### +class ifcderivedunit(BaseEntityClass): + '''Entity ifcderivedunit definition. + + :param elements + :type elements:SET(1,None,'ifcderivedunitelement', scope = schema_scope) + + :param unittype + :type unittype:ifcderivedunitenum + + :param userdefinedtype + :type userdefinedtype:ifclabel + + :param dimensions + :type dimensions:ifcdimensionalexponents + ''' + def __init__( self , elements,unittype,userdefinedtype, ): + self.elements = elements + self.unittype = unittype + self.userdefinedtype = userdefinedtype + + @apply + def elements(): + def fget( self ): + return self._elements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument elements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcderivedunitelement', scope = schema_scope)): + self._elements = SET(value) + else: + self._elements = value + return property(**locals()) + + @apply + def unittype(): + def fget( self ): + return self._unittype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unittype is mantatory and can not be set to None') + if not check_type(value,ifcderivedunitenum): + self._unittype = ifcderivedunitenum(value) + else: + self._unittype = value + return property(**locals()) + + @apply + def userdefinedtype(): + def fget( self ): + return self._userdefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedtype = ifclabel(value) + else: + self._userdefinedtype = value + else: + self._userdefinedtype = value + return property(**locals()) + + @apply + def dimensions(): + def fget( self ): + attribute_eval = ifcderivedimensionalexponents(self.elements) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dimensions is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((SIZEOF(self.elements) > 1) or ((SIZEOF(self.elements) == 1) and (self.elements[1].self.exponent != 1))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((self.unittype != ifcderivedunitenum.self.userdefined) or ((self.unittype == ifcderivedunitenum.self.userdefined) and EXISTS(self.self.userdefinedtype))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifccontrollertype # +#################### +class ifccontrollertype(ifcdistributioncontrolelementtype): + '''Entity ifccontrollertype definition. + + :param predefinedtype + :type predefinedtype:ifccontrollertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccontrollertypeenum): + self._predefinedtype = ifccontrollertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcrelassignstoproduct # +#################### +class ifcrelassignstoproduct(ifcrelassigns): + '''Entity ifcrelassignstoproduct definition. + + :param relatingproduct + :type relatingproduct:ifcproduct + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingproduct, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingproduct = relatingproduct + + @apply + def relatingproduct(): + def fget( self ): + return self._relatingproduct + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingproduct is mantatory and can not be set to None') + if not check_type(value,ifcproduct): + self._relatingproduct = ifcproduct(value) + else: + self._relatingproduct = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcelectricheatertype # +#################### +class ifcelectricheatertype(ifcflowterminaltype): + '''Entity ifcelectricheatertype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricheatertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricheatertypeenum): + self._predefinedtype = ifcelectricheatertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcrepresentationcontext # +#################### +class ifcrepresentationcontext(BaseEntityClass): + '''Entity ifcrepresentationcontext definition. + + :param contextidentifier + :type contextidentifier:ifclabel + + :param contexttype + :type contexttype:ifclabel + + :param representationsincontext + :type representationsincontext:SET(0,None,'ifcrepresentation', scope = schema_scope) + ''' + def __init__( self , contextidentifier,contexttype, ): + self.contextidentifier = contextidentifier + self.contexttype = contexttype + + @apply + def contextidentifier(): + def fget( self ): + return self._contextidentifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._contextidentifier = ifclabel(value) + else: + self._contextidentifier = value + else: + self._contextidentifier = value + return property(**locals()) + + @apply + def contexttype(): + def fget( self ): + return self._contexttype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._contexttype = ifclabel(value) + else: + self._contexttype = value + else: + self._contexttype = value + return property(**locals()) + + @apply + def representationsincontext(): + def fget( self ): + return self._representationsincontext + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument representationsincontext is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcgeometricrepresentationcontext # +#################### +class ifcgeometricrepresentationcontext(ifcrepresentationcontext): + '''Entity ifcgeometricrepresentationcontext definition. + + :param coordinatespacedimension + :type coordinatespacedimension:ifcdimensioncount + + :param precision + :type precision:REAL + + :param worldcoordinatesystem + :type worldcoordinatesystem:ifcaxis2placement + + :param truenorth + :type truenorth:ifcdirection + + :param hassubcontexts + :type hassubcontexts:SET(0,None,'ifcgeometricrepresentationsubcontext', scope = schema_scope) + ''' + def __init__( self , inherited0__contextidentifier , inherited1__contexttype , coordinatespacedimension,precision,worldcoordinatesystem,truenorth, ): + ifcrepresentationcontext.__init__(self , inherited0__contextidentifier , inherited1__contexttype , ) + self.coordinatespacedimension = coordinatespacedimension + self.precision = precision + self.worldcoordinatesystem = worldcoordinatesystem + self.truenorth = truenorth + + @apply + def coordinatespacedimension(): + def fget( self ): + return self._coordinatespacedimension + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordinatespacedimension is mantatory and can not be set to None') + if not check_type(value,ifcdimensioncount): + self._coordinatespacedimension = ifcdimensioncount(value) + else: + self._coordinatespacedimension = value + return property(**locals()) + + @apply + def precision(): + def fget( self ): + return self._precision + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._precision = REAL(value) + else: + self._precision = value + else: + self._precision = value + return property(**locals()) + + @apply + def worldcoordinatesystem(): + def fget( self ): + return self._worldcoordinatesystem + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument worldcoordinatesystem is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._worldcoordinatesystem = ifcaxis2placement(value) + else: + self._worldcoordinatesystem = value + return property(**locals()) + + @apply + def truenorth(): + def fget( self ): + return self._truenorth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._truenorth = ifcdirection(value) + else: + self._truenorth = value + else: + self._truenorth = value + return property(**locals()) + + @apply + def hassubcontexts(): + def fget( self ): + return self._hassubcontexts + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hassubcontexts is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstairflight # +#################### +class ifcstairflight(ifcbuildingelement): + '''Entity ifcstairflight definition. + + :param numberofriser + :type numberofriser:INTEGER + + :param numberoftreads + :type numberoftreads:INTEGER + + :param riserheight + :type riserheight:ifcpositivelengthmeasure + + :param treadlength + :type treadlength:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , numberofriser,numberoftreads,riserheight,treadlength, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.numberofriser = numberofriser + self.numberoftreads = numberoftreads + self.riserheight = riserheight + self.treadlength = treadlength + + @apply + def numberofriser(): + def fget( self ): + return self._numberofriser + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,INTEGER): + self._numberofriser = INTEGER(value) + else: + self._numberofriser = value + else: + self._numberofriser = value + return property(**locals()) + + @apply + def numberoftreads(): + def fget( self ): + return self._numberoftreads + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,INTEGER): + self._numberoftreads = INTEGER(value) + else: + self._numberoftreads = value + else: + self._numberoftreads = value + return property(**locals()) + + @apply + def riserheight(): + def fget( self ): + return self._riserheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._riserheight = ifcpositivelengthmeasure(value) + else: + self._riserheight = value + else: + self._riserheight = value + return property(**locals()) + + @apply + def treadlength(): + def fget( self ): + return self._treadlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._treadlength = ifcpositivelengthmeasure(value) + else: + self._treadlength = value + else: + self._treadlength = value + return property(**locals()) + +#################### + # ENTITY ifcpath # +#################### +class ifcpath(ifctopologicalrepresentationitem): + '''Entity ifcpath definition. + + :param edgelist + :type edgelist:LIST(1,None,'ifcorientededge', scope = schema_scope) + ''' + def __init__( self , edgelist, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.edgelist = edgelist + + @apply + def edgelist(): + def fget( self ): + return self._edgelist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgelist is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcorientededge', scope = schema_scope)): + self._edgelist = LIST(value) + else: + self._edgelist = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ifcpathheadtotail(self) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcstair # +#################### +class ifcstair(ifcbuildingelement): + '''Entity ifcstair definition. + + :param shapetype + :type shapetype:ifcstairtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , shapetype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.shapetype = shapetype + + @apply + def shapetype(): + def fget( self ): + return self._shapetype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument shapetype is mantatory and can not be set to None') + if not check_type(value,ifcstairtypeenum): + self._shapetype = ifcstairtypeenum(value) + else: + self._shapetype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 0) or ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 1) and ( not EXISTS(self.self.ifcproduct.self.representation)))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifc2dcompositecurve # +#################### +class ifc2dcompositecurve(ifccompositecurve): + '''Entity ifc2dcompositecurve definition. + ''' + def __init__( self , inherited0__segments , inherited1__selfintersect , ): + ifccompositecurve.__init__(self , inherited0__segments , inherited1__selfintersect , ) + def wr1(self): + eval_wr1_wr = self.self.ifccompositecurve.self.closedcurve + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.ifccurve.self.dim == 2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcactorrole # +#################### +class ifcactorrole(BaseEntityClass): + '''Entity ifcactorrole definition. + + :param role + :type role:ifcroleenum + + :param userdefinedrole + :type userdefinedrole:ifclabel + + :param description + :type description:ifctext + ''' + def __init__( self , role,userdefinedrole,description, ): + self.role = role + self.userdefinedrole = userdefinedrole + self.description = description + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,ifcroleenum): + self._role = ifcroleenum(value) + else: + self._role = value + return property(**locals()) + + @apply + def userdefinedrole(): + def fget( self ): + return self._userdefinedrole + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedrole = ifclabel(value) + else: + self._userdefinedrole = value + else: + self._userdefinedrole = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.role != ifcroleenum.self.userdefined) or ((self.role == ifcroleenum.self.userdefined) and EXISTS(self.self.userdefinedrole))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcpolyline # +#################### +class ifcpolyline(ifcboundedcurve): + '''Entity ifcpolyline definition. + + :param points + :type points:LIST(2,None,'ifccartesianpoint', scope = schema_scope) + ''' + def __init__( self , points, ): + ifcboundedcurve.__init__(self , ) + self.points = points + + @apply + def points(): + def fget( self ): + return self._points + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument points is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'ifccartesianpoint', scope = schema_scope)): + self._points = LIST(value) + else: + self._points = value + return property(**locals()) + def wr41(self): + eval_wr41_wr = (SIZEOF(None) == 0) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + +#################### + # ENTITY ifcgeometriccurveset # +#################### +class ifcgeometriccurveset(ifcgeometricset): + '''Entity ifcgeometriccurveset definition. + ''' + def __init__( self , inherited0__elements , ): + ifcgeometricset.__init__(self , inherited0__elements , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifctablerow # +#################### +class ifctablerow(BaseEntityClass): + '''Entity ifctablerow definition. + + :param rowcells + :type rowcells:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param isheading + :type isheading:BOOLEAN + + :param oftable + :type oftable:ifctable + ''' + def __init__( self , rowcells,isheading, ): + self.rowcells = rowcells + self.isheading = isheading + + @apply + def rowcells(): + def fget( self ): + return self._rowcells + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rowcells is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._rowcells = LIST(value) + else: + self._rowcells = value + return property(**locals()) + + @apply + def isheading(): + def fget( self ): + return self._isheading + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument isheading is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._isheading = BOOLEAN(value) + else: + self._isheading = value + return property(**locals()) + + @apply + def oftable(): + def fget( self ): + return self._oftable + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument oftable is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcconnectionsurfacegeometry # +#################### +class ifcconnectionsurfacegeometry(ifcconnectiongeometry): + '''Entity ifcconnectionsurfacegeometry definition. + + :param surfaceonrelatingelement + :type surfaceonrelatingelement:ifcsurfaceorfacesurface + + :param surfaceonrelatedelement + :type surfaceonrelatedelement:ifcsurfaceorfacesurface + ''' + def __init__( self , surfaceonrelatingelement,surfaceonrelatedelement, ): + ifcconnectiongeometry.__init__(self , ) + self.surfaceonrelatingelement = surfaceonrelatingelement + self.surfaceonrelatedelement = surfaceonrelatedelement + + @apply + def surfaceonrelatingelement(): + def fget( self ): + return self._surfaceonrelatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument surfaceonrelatingelement is mantatory and can not be set to None') + if not check_type(value,ifcsurfaceorfacesurface): + self._surfaceonrelatingelement = ifcsurfaceorfacesurface(value) + else: + self._surfaceonrelatingelement = value + return property(**locals()) + + @apply + def surfaceonrelatedelement(): + def fget( self ): + return self._surfaceonrelatedelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsurfaceorfacesurface): + self._surfaceonrelatedelement = ifcsurfaceorfacesurface(value) + else: + self._surfaceonrelatedelement = value + else: + self._surfaceonrelatedelement = value + return property(**locals()) + +#################### + # ENTITY ifcopticalmaterialproperties # +#################### +class ifcopticalmaterialproperties(ifcmaterialproperties): + '''Entity ifcopticalmaterialproperties definition. + + :param visibletransmittance + :type visibletransmittance:ifcpositiveratiomeasure + + :param solartransmittance + :type solartransmittance:ifcpositiveratiomeasure + + :param thermalirtransmittance + :type thermalirtransmittance:ifcpositiveratiomeasure + + :param thermaliremissivityback + :type thermaliremissivityback:ifcpositiveratiomeasure + + :param thermaliremissivityfront + :type thermaliremissivityfront:ifcpositiveratiomeasure + + :param visiblereflectanceback + :type visiblereflectanceback:ifcpositiveratiomeasure + + :param visiblereflectancefront + :type visiblereflectancefront:ifcpositiveratiomeasure + + :param solarreflectancefront + :type solarreflectancefront:ifcpositiveratiomeasure + + :param solarreflectanceback + :type solarreflectanceback:ifcpositiveratiomeasure + ''' + def __init__( self , inherited0__material , visibletransmittance,solartransmittance,thermalirtransmittance,thermaliremissivityback,thermaliremissivityfront,visiblereflectanceback,visiblereflectancefront,solarreflectancefront,solarreflectanceback, ): + ifcmaterialproperties.__init__(self , inherited0__material , ) + self.visibletransmittance = visibletransmittance + self.solartransmittance = solartransmittance + self.thermalirtransmittance = thermalirtransmittance + self.thermaliremissivityback = thermaliremissivityback + self.thermaliremissivityfront = thermaliremissivityfront + self.visiblereflectanceback = visiblereflectanceback + self.visiblereflectancefront = visiblereflectancefront + self.solarreflectancefront = solarreflectancefront + self.solarreflectanceback = solarreflectanceback + + @apply + def visibletransmittance(): + def fget( self ): + return self._visibletransmittance + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._visibletransmittance = ifcpositiveratiomeasure(value) + else: + self._visibletransmittance = value + else: + self._visibletransmittance = value + return property(**locals()) + + @apply + def solartransmittance(): + def fget( self ): + return self._solartransmittance + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._solartransmittance = ifcpositiveratiomeasure(value) + else: + self._solartransmittance = value + else: + self._solartransmittance = value + return property(**locals()) + + @apply + def thermalirtransmittance(): + def fget( self ): + return self._thermalirtransmittance + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._thermalirtransmittance = ifcpositiveratiomeasure(value) + else: + self._thermalirtransmittance = value + else: + self._thermalirtransmittance = value + return property(**locals()) + + @apply + def thermaliremissivityback(): + def fget( self ): + return self._thermaliremissivityback + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._thermaliremissivityback = ifcpositiveratiomeasure(value) + else: + self._thermaliremissivityback = value + else: + self._thermaliremissivityback = value + return property(**locals()) + + @apply + def thermaliremissivityfront(): + def fget( self ): + return self._thermaliremissivityfront + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._thermaliremissivityfront = ifcpositiveratiomeasure(value) + else: + self._thermaliremissivityfront = value + else: + self._thermaliremissivityfront = value + return property(**locals()) + + @apply + def visiblereflectanceback(): + def fget( self ): + return self._visiblereflectanceback + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._visiblereflectanceback = ifcpositiveratiomeasure(value) + else: + self._visiblereflectanceback = value + else: + self._visiblereflectanceback = value + return property(**locals()) + + @apply + def visiblereflectancefront(): + def fget( self ): + return self._visiblereflectancefront + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._visiblereflectancefront = ifcpositiveratiomeasure(value) + else: + self._visiblereflectancefront = value + else: + self._visiblereflectancefront = value + return property(**locals()) + + @apply + def solarreflectancefront(): + def fget( self ): + return self._solarreflectancefront + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._solarreflectancefront = ifcpositiveratiomeasure(value) + else: + self._solarreflectancefront = value + else: + self._solarreflectancefront = value + return property(**locals()) + + @apply + def solarreflectanceback(): + def fget( self ): + return self._solarreflectanceback + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._solarreflectanceback = ifcpositiveratiomeasure(value) + else: + self._solarreflectanceback = value + else: + self._solarreflectanceback = value + return property(**locals()) + +#################### + # ENTITY ifcprojectioncurve # +#################### +class ifcprojectioncurve(ifcannotationcurveoccurrence): + '''Entity ifcprojectioncurve definition. + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , ): + ifcannotationcurveoccurrence.__init__(self , inherited0__item , inherited1__styles , inherited2__name , ) + +#################### + # ENTITY ifcsoundvalue # +#################### +class ifcsoundvalue(ifcpropertysetdefinition): + '''Entity ifcsoundvalue definition. + + :param soundleveltimeseries + :type soundleveltimeseries:ifctimeseries + + :param frequency + :type frequency:ifcfrequencymeasure + + :param soundlevelsinglevalue + :type soundlevelsinglevalue:ifcderivedmeasurevalue + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , soundleveltimeseries,frequency,soundlevelsinglevalue, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.soundleveltimeseries = soundleveltimeseries + self.frequency = frequency + self.soundlevelsinglevalue = soundlevelsinglevalue + + @apply + def soundleveltimeseries(): + def fget( self ): + return self._soundleveltimeseries + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimeseries): + self._soundleveltimeseries = ifctimeseries(value) + else: + self._soundleveltimeseries = value + else: + self._soundleveltimeseries = value + return property(**locals()) + + @apply + def frequency(): + def fget( self ): + return self._frequency + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument frequency is mantatory and can not be set to None') + if not check_type(value,ifcfrequencymeasure): + self._frequency = ifcfrequencymeasure(value) + else: + self._frequency = value + return property(**locals()) + + @apply + def soundlevelsinglevalue(): + def fget( self ): + return self._soundlevelsinglevalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcderivedmeasurevalue): + self._soundlevelsinglevalue = ifcderivedmeasurevalue(value) + else: + self._soundlevelsinglevalue = value + else: + self._soundlevelsinglevalue = value + return property(**locals()) + +#################### + # ENTITY ifccalendardate # +#################### +class ifccalendardate(BaseEntityClass): + '''Entity ifccalendardate definition. + + :param daycomponent + :type daycomponent:ifcdayinmonthnumber + + :param monthcomponent + :type monthcomponent:ifcmonthinyearnumber + + :param yearcomponent + :type yearcomponent:ifcyearnumber + ''' + def __init__( self , daycomponent,monthcomponent,yearcomponent, ): + self.daycomponent = daycomponent + self.monthcomponent = monthcomponent + self.yearcomponent = yearcomponent + + @apply + def daycomponent(): + def fget( self ): + return self._daycomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument daycomponent is mantatory and can not be set to None') + if not check_type(value,ifcdayinmonthnumber): + self._daycomponent = ifcdayinmonthnumber(value) + else: + self._daycomponent = value + return property(**locals()) + + @apply + def monthcomponent(): + def fget( self ): + return self._monthcomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument monthcomponent is mantatory and can not be set to None') + if not check_type(value,ifcmonthinyearnumber): + self._monthcomponent = ifcmonthinyearnumber(value) + else: + self._monthcomponent = value + return property(**locals()) + + @apply + def yearcomponent(): + def fget( self ): + return self._yearcomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument yearcomponent is mantatory and can not be set to None') + if not check_type(value,ifcyearnumber): + self._yearcomponent = ifcyearnumber(value) + else: + self._yearcomponent = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ifcvalidcalendardate(self) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcderivedprofiledef # +#################### +class ifcderivedprofiledef(ifcprofiledef): + '''Entity ifcderivedprofiledef definition. + + :param parentprofile + :type parentprofile:ifcprofiledef + + :param operator + :type operator:ifccartesiantransformationoperator2d + + :param label + :type label:ifclabel + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , parentprofile,operator,label, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.parentprofile = parentprofile + self.operator = operator + self.label = label + + @apply + def parentprofile(): + def fget( self ): + return self._parentprofile + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parentprofile is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._parentprofile = ifcprofiledef(value) + else: + self._parentprofile = value + return property(**locals()) + + @apply + def operator(): + def fget( self ): + return self._operator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operator is mantatory and can not be set to None') + if not check_type(value,ifccartesiantransformationoperator2d): + self._operator = ifccartesiantransformationoperator2d(value) + else: + self._operator = value + return property(**locals()) + + @apply + def label(): + def fget( self ): + return self._label + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._label = ifclabel(value) + else: + self._label = value + else: + self._label = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.ifcprofiledef.self.profiletype == self.parentprofile.self.profiletype) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcflowmovingdevicetype # +#################### +class ifcflowmovingdevicetype(ifcdistributionflowelementtype): + '''Entity ifcflowmovingdevicetype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcfantype # +#################### +class ifcfantype(ifcflowmovingdevicetype): + '''Entity ifcfantype definition. + + :param predefinedtype + :type predefinedtype:ifcfantypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowmovingdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcfantypeenum): + self._predefinedtype = ifcfantypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcfantypeenum.self.userdefined) or ((self.predefinedtype == ifcfantypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcobjectplacement # +#################### +class ifcobjectplacement(BaseEntityClass): + '''Entity ifcobjectplacement definition. + + :param placesobject + :type placesobject:SET(1,1,'ifcproduct', scope = schema_scope) + + :param referencedbyplacements + :type referencedbyplacements:SET(0,None,'ifclocalplacement', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def placesobject(): + def fget( self ): + return self._placesobject + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument placesobject is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def referencedbyplacements(): + def fget( self ): + return self._referencedbyplacements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referencedbyplacements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcgridplacement # +#################### +class ifcgridplacement(ifcobjectplacement): + '''Entity ifcgridplacement definition. + + :param placementlocation + :type placementlocation:ifcvirtualgridintersection + + :param placementrefdirection + :type placementrefdirection:ifcvirtualgridintersection + ''' + def __init__( self , placementlocation,placementrefdirection, ): + ifcobjectplacement.__init__(self , ) + self.placementlocation = placementlocation + self.placementrefdirection = placementrefdirection + + @apply + def placementlocation(): + def fget( self ): + return self._placementlocation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placementlocation is mantatory and can not be set to None') + if not check_type(value,ifcvirtualgridintersection): + self._placementlocation = ifcvirtualgridintersection(value) + else: + self._placementlocation = value + return property(**locals()) + + @apply + def placementrefdirection(): + def fget( self ): + return self._placementrefdirection + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvirtualgridintersection): + self._placementrefdirection = ifcvirtualgridintersection(value) + else: + self._placementrefdirection = value + else: + self._placementrefdirection = value + return property(**locals()) + +#################### + # ENTITY ifctextstylefontmodel # +#################### +class ifctextstylefontmodel(ifcpredefinedtextfont): + '''Entity ifctextstylefontmodel definition. + + :param fontfamily + :type fontfamily:LIST(1,None,'STRING', scope = schema_scope) + + :param fontstyle + :type fontstyle:ifcfontstyle + + :param fontvariant + :type fontvariant:ifcfontvariant + + :param fontweight + :type fontweight:ifcfontweight + + :param fontsize + :type fontsize:ifcsizeselect + ''' + def __init__( self , inherited0__name , fontfamily,fontstyle,fontvariant,fontweight,fontsize, ): + ifcpredefinedtextfont.__init__(self , inherited0__name , ) + self.fontfamily = fontfamily + self.fontstyle = fontstyle + self.fontvariant = fontvariant + self.fontweight = fontweight + self.fontsize = fontsize + + @apply + def fontfamily(): + def fget( self ): + return self._fontfamily + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._fontfamily = LIST(value) + else: + self._fontfamily = value + else: + self._fontfamily = value + return property(**locals()) + + @apply + def fontstyle(): + def fget( self ): + return self._fontstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfontstyle): + self._fontstyle = ifcfontstyle(value) + else: + self._fontstyle = value + else: + self._fontstyle = value + return property(**locals()) + + @apply + def fontvariant(): + def fget( self ): + return self._fontvariant + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfontvariant): + self._fontvariant = ifcfontvariant(value) + else: + self._fontvariant = value + else: + self._fontvariant = value + return property(**locals()) + + @apply + def fontweight(): + def fget( self ): + return self._fontweight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfontweight): + self._fontweight = ifcfontweight(value) + else: + self._fontweight = value + else: + self._fontweight = value + return property(**locals()) + + @apply + def fontsize(): + def fget( self ): + return self._fontsize + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fontsize is mantatory and can not be set to None') + if not check_type(value,ifcsizeselect): + self._fontsize = ifcsizeselect(value) + else: + self._fontsize = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (('IFC2X3.IFCLENGTHMEASURE' == TYPEOF(self.self.fontsize)) and (self.self.fontsize > 0)) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcflowfitting # +#################### +class ifcflowfitting(ifcdistributionflowelement): + '''Entity ifcflowfitting definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcprotectivedevicetype # +#################### +class ifcprotectivedevicetype(ifcflowcontrollertype): + '''Entity ifcprotectivedevicetype definition. + + :param predefinedtype + :type predefinedtype:ifcprotectivedevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcprotectivedevicetypeenum): + self._predefinedtype = ifcprotectivedevicetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifccircleprofiledef # +#################### +class ifccircleprofiledef(ifcparameterizedprofiledef): + '''Entity ifccircleprofiledef definition. + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , radius, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifcwindowpanelproperties # +#################### +class ifcwindowpanelproperties(ifcpropertysetdefinition): + '''Entity ifcwindowpanelproperties definition. + + :param operationtype + :type operationtype:ifcwindowpaneloperationenum + + :param panelposition + :type panelposition:ifcwindowpanelpositionenum + + :param framedepth + :type framedepth:ifcpositivelengthmeasure + + :param framethickness + :type framethickness:ifcpositivelengthmeasure + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , operationtype,panelposition,framedepth,framethickness,shapeaspectstyle, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.operationtype = operationtype + self.panelposition = panelposition + self.framedepth = framedepth + self.framethickness = framethickness + self.shapeaspectstyle = shapeaspectstyle + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operationtype is mantatory and can not be set to None') + if not check_type(value,ifcwindowpaneloperationenum): + self._operationtype = ifcwindowpaneloperationenum(value) + else: + self._operationtype = value + return property(**locals()) + + @apply + def panelposition(): + def fget( self ): + return self._panelposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument panelposition is mantatory and can not be set to None') + if not check_type(value,ifcwindowpanelpositionenum): + self._panelposition = ifcwindowpanelpositionenum(value) + else: + self._panelposition = value + return property(**locals()) + + @apply + def framedepth(): + def fget( self ): + return self._framedepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._framedepth = ifcpositivelengthmeasure(value) + else: + self._framedepth = value + else: + self._framedepth = value + return property(**locals()) + + @apply + def framethickness(): + def fget( self ): + return self._framethickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._framethickness = ifcpositivelengthmeasure(value) + else: + self._framethickness = value + else: + self._framethickness = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + +#################### + # ENTITY ifcdimensionalexponents # +#################### +class ifcdimensionalexponents(BaseEntityClass): + '''Entity ifcdimensionalexponents definition. + + :param lengthexponent + :type lengthexponent:INTEGER + + :param massexponent + :type massexponent:INTEGER + + :param timeexponent + :type timeexponent:INTEGER + + :param electriccurrentexponent + :type electriccurrentexponent:INTEGER + + :param thermodynamictemperatureexponent + :type thermodynamictemperatureexponent:INTEGER + + :param amountofsubstanceexponent + :type amountofsubstanceexponent:INTEGER + + :param luminousintensityexponent + :type luminousintensityexponent:INTEGER + ''' + def __init__( self , lengthexponent,massexponent,timeexponent,electriccurrentexponent,thermodynamictemperatureexponent,amountofsubstanceexponent,luminousintensityexponent, ): + self.lengthexponent = lengthexponent + self.massexponent = massexponent + self.timeexponent = timeexponent + self.electriccurrentexponent = electriccurrentexponent + self.thermodynamictemperatureexponent = thermodynamictemperatureexponent + self.amountofsubstanceexponent = amountofsubstanceexponent + self.luminousintensityexponent = luminousintensityexponent + + @apply + def lengthexponent(): + def fget( self ): + return self._lengthexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lengthexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._lengthexponent = INTEGER(value) + else: + self._lengthexponent = value + return property(**locals()) + + @apply + def massexponent(): + def fget( self ): + return self._massexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument massexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._massexponent = INTEGER(value) + else: + self._massexponent = value + return property(**locals()) + + @apply + def timeexponent(): + def fget( self ): + return self._timeexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timeexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._timeexponent = INTEGER(value) + else: + self._timeexponent = value + return property(**locals()) + + @apply + def electriccurrentexponent(): + def fget( self ): + return self._electriccurrentexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument electriccurrentexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._electriccurrentexponent = INTEGER(value) + else: + self._electriccurrentexponent = value + return property(**locals()) + + @apply + def thermodynamictemperatureexponent(): + def fget( self ): + return self._thermodynamictemperatureexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument thermodynamictemperatureexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._thermodynamictemperatureexponent = INTEGER(value) + else: + self._thermodynamictemperatureexponent = value + return property(**locals()) + + @apply + def amountofsubstanceexponent(): + def fget( self ): + return self._amountofsubstanceexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument amountofsubstanceexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._amountofsubstanceexponent = INTEGER(value) + else: + self._amountofsubstanceexponent = value + return property(**locals()) + + @apply + def luminousintensityexponent(): + def fget( self ): + return self._luminousintensityexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument luminousintensityexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._luminousintensityexponent = INTEGER(value) + else: + self._luminousintensityexponent = value + return property(**locals()) + +#################### + # ENTITY ifcextendedmaterialproperties # +#################### +class ifcextendedmaterialproperties(ifcmaterialproperties): + '''Entity ifcextendedmaterialproperties definition. + + :param extendedproperties + :type extendedproperties:SET(1,None,'ifcproperty', scope = schema_scope) + + :param description + :type description:ifctext + + :param name + :type name:ifclabel + ''' + def __init__( self , inherited0__material , extendedproperties,description,name, ): + ifcmaterialproperties.__init__(self , inherited0__material , ) + self.extendedproperties = extendedproperties + self.description = description + self.name = name + + @apply + def extendedproperties(): + def fget( self ): + return self._extendedproperties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extendedproperties is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproperty', scope = schema_scope)): + self._extendedproperties = SET(value) + else: + self._extendedproperties = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcmetric # +#################### +class ifcmetric(ifcconstraint): + '''Entity ifcmetric definition. + + :param benchmark + :type benchmark:ifcbenchmarkenum + + :param valuesource + :type valuesource:ifclabel + + :param datavalue + :type datavalue:ifcmetricvalueselect + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__constraintgrade , inherited3__constraintsource , inherited4__creatingactor , inherited5__creationtime , inherited6__userdefinedgrade , benchmark,valuesource,datavalue, ): + ifcconstraint.__init__(self , inherited0__name , inherited1__description , inherited2__constraintgrade , inherited3__constraintsource , inherited4__creatingactor , inherited5__creationtime , inherited6__userdefinedgrade , ) + self.benchmark = benchmark + self.valuesource = valuesource + self.datavalue = datavalue + + @apply + def benchmark(): + def fget( self ): + return self._benchmark + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument benchmark is mantatory and can not be set to None') + if not check_type(value,ifcbenchmarkenum): + self._benchmark = ifcbenchmarkenum(value) + else: + self._benchmark = value + return property(**locals()) + + @apply + def valuesource(): + def fget( self ): + return self._valuesource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._valuesource = ifclabel(value) + else: + self._valuesource = value + else: + self._valuesource = value + return property(**locals()) + + @apply + def datavalue(): + def fget( self ): + return self._datavalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument datavalue is mantatory and can not be set to None') + if not check_type(value,ifcmetricvalueselect): + self._datavalue = ifcmetricvalueselect(value) + else: + self._datavalue = value + return property(**locals()) + +#################### + # ENTITY ifcpredefinedpointmarkersymbol # +#################### +class ifcpredefinedpointmarkersymbol(ifcpredefinedsymbol): + '''Entity ifcpredefinedpointmarkersymbol definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefinedsymbol.__init__(self , inherited0__name , ) + def wr31(self): + eval_wr31_wr = (self.self.ifcpredefineditem.self.name == ['asterisk','circle','dot','plus','square','triangle','x']) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcapprovalpropertyrelationship # +#################### +class ifcapprovalpropertyrelationship(BaseEntityClass): + '''Entity ifcapprovalpropertyrelationship definition. + + :param approvedproperties + :type approvedproperties:SET(1,None,'ifcproperty', scope = schema_scope) + + :param approval + :type approval:ifcapproval + ''' + def __init__( self , approvedproperties,approval, ): + self.approvedproperties = approvedproperties + self.approval = approval + + @apply + def approvedproperties(): + def fget( self ): + return self._approvedproperties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument approvedproperties is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproperty', scope = schema_scope)): + self._approvedproperties = SET(value) + else: + self._approvedproperties = value + return property(**locals()) + + @apply + def approval(): + def fget( self ): + return self._approval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument approval is mantatory and can not be set to None') + if not check_type(value,ifcapproval): + self._approval = ifcapproval(value) + else: + self._approval = value + return property(**locals()) + +#################### + # ENTITY ifccoordinateduniversaltimeoffset # +#################### +class ifccoordinateduniversaltimeoffset(BaseEntityClass): + '''Entity ifccoordinateduniversaltimeoffset definition. + + :param houroffset + :type houroffset:ifchourinday + + :param minuteoffset + :type minuteoffset:ifcminuteinhour + + :param sense + :type sense:ifcaheadorbehind + ''' + def __init__( self , houroffset,minuteoffset,sense, ): + self.houroffset = houroffset + self.minuteoffset = minuteoffset + self.sense = sense + + @apply + def houroffset(): + def fget( self ): + return self._houroffset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument houroffset is mantatory and can not be set to None') + if not check_type(value,ifchourinday): + self._houroffset = ifchourinday(value) + else: + self._houroffset = value + return property(**locals()) + + @apply + def minuteoffset(): + def fget( self ): + return self._minuteoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcminuteinhour): + self._minuteoffset = ifcminuteinhour(value) + else: + self._minuteoffset = value + else: + self._minuteoffset = value + return property(**locals()) + + @apply + def sense(): + def fget( self ): + return self._sense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sense is mantatory and can not be set to None') + if not check_type(value,ifcaheadorbehind): + self._sense = ifcaheadorbehind(value) + else: + self._sense = value + return property(**locals()) + +#################### + # ENTITY ifcrelconnectswithrealizingelements # +#################### +class ifcrelconnectswithrealizingelements(ifcrelconnectselements): + '''Entity ifcrelconnectswithrealizingelements definition. + + :param realizingelements + :type realizingelements:SET(1,None,'ifcelement', scope = schema_scope) + + :param connectiontype + :type connectiontype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__connectiongeometry , inherited5__relatingelement , inherited6__relatedelement , realizingelements,connectiontype, ): + ifcrelconnectselements.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__connectiongeometry , inherited5__relatingelement , inherited6__relatedelement , ) + self.realizingelements = realizingelements + self.connectiontype = connectiontype + + @apply + def realizingelements(): + def fget( self ): + return self._realizingelements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument realizingelements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcelement', scope = schema_scope)): + self._realizingelements = SET(value) + else: + self._realizingelements = value + return property(**locals()) + + @apply + def connectiontype(): + def fget( self ): + return self._connectiontype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._connectiontype = ifclabel(value) + else: + self._connectiontype = value + else: + self._connectiontype = value + return property(**locals()) + +#################### + # ENTITY ifcprocess # +#################### +class ifcprocess(ifcobject): + '''Entity ifcprocess definition. + + :param operateson + :type operateson:SET(0,None,'ifcrelassignstoprocess', scope = schema_scope) + + :param issuccessorfrom + :type issuccessorfrom:SET(0,None,'ifcrelsequence', scope = schema_scope) + + :param ispredecessorto + :type ispredecessorto:SET(0,None,'ifcrelsequence', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + + @apply + def operateson(): + def fget( self ): + return self._operateson + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument operateson is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def issuccessorfrom(): + def fget( self ): + return self._issuccessorfrom + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument issuccessorfrom is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ispredecessorto(): + def fget( self ): + return self._ispredecessorto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ispredecessorto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifctask # +#################### +class ifctask(ifcprocess): + '''Entity ifctask definition. + + :param taskid + :type taskid:ifcidentifier + + :param status + :type status:ifclabel + + :param workmethod + :type workmethod:ifclabel + + :param ismilestone + :type ismilestone:BOOLEAN + + :param priority + :type priority:INTEGER + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , taskid,status,workmethod,ismilestone,priority, ): + ifcprocess.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.taskid = taskid + self.status = status + self.workmethod = workmethod + self.ismilestone = ismilestone + self.priority = priority + + @apply + def taskid(): + def fget( self ): + return self._taskid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument taskid is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._taskid = ifcidentifier(value) + else: + self._taskid = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._status = ifclabel(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def workmethod(): + def fget( self ): + return self._workmethod + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._workmethod = ifclabel(value) + else: + self._workmethod = value + else: + self._workmethod = value + return property(**locals()) + + @apply + def ismilestone(): + def fget( self ): + return self._ismilestone + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ismilestone is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._ismilestone = BOOLEAN(value) + else: + self._ismilestone = value + return property(**locals()) + + @apply + def priority(): + def fget( self ): + return self._priority + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,INTEGER): + self._priority = INTEGER(value) + else: + self._priority = value + else: + self._priority = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcresource # +#################### +class ifcresource(ifcobject): + '''Entity ifcresource definition. + + :param resourceof + :type resourceof:SET(0,None,'ifcrelassignstoresource', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + + @apply + def resourceof(): + def fget( self ): + return self._resourceof + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument resourceof is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcconstructionresource # +#################### +class ifcconstructionresource(ifcresource): + '''Entity ifcconstructionresource definition. + + :param resourceidentifier + :type resourceidentifier:ifcidentifier + + :param resourcegroup + :type resourcegroup:ifclabel + + :param resourceconsumption + :type resourceconsumption:ifcresourceconsumptionenum + + :param basequantity + :type basequantity:ifcmeasurewithunit + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , resourceidentifier,resourcegroup,resourceconsumption,basequantity, ): + ifcresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.resourceidentifier = resourceidentifier + self.resourcegroup = resourcegroup + self.resourceconsumption = resourceconsumption + self.basequantity = basequantity + + @apply + def resourceidentifier(): + def fget( self ): + return self._resourceidentifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._resourceidentifier = ifcidentifier(value) + else: + self._resourceidentifier = value + else: + self._resourceidentifier = value + return property(**locals()) + + @apply + def resourcegroup(): + def fget( self ): + return self._resourcegroup + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._resourcegroup = ifclabel(value) + else: + self._resourcegroup = value + else: + self._resourcegroup = value + return property(**locals()) + + @apply + def resourceconsumption(): + def fget( self ): + return self._resourceconsumption + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcresourceconsumptionenum): + self._resourceconsumption = ifcresourceconsumptionenum(value) + else: + self._resourceconsumption = value + else: + self._resourceconsumption = value + return property(**locals()) + + @apply + def basequantity(): + def fget( self ): + return self._basequantity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmeasurewithunit): + self._basequantity = ifcmeasurewithunit(value) + else: + self._basequantity = value + else: + self._basequantity = value + return property(**locals()) + +#################### + # ENTITY ifccrewresource # +#################### +class ifccrewresource(ifcconstructionresource): + '''Entity ifccrewresource definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , ) + +#################### + # ENTITY ifcmanifoldsolidbrep # +#################### +class ifcmanifoldsolidbrep(ifcsolidmodel): + '''Entity ifcmanifoldsolidbrep definition. + + :param outer + :type outer:ifcclosedshell + ''' + def __init__( self , outer, ): + ifcsolidmodel.__init__(self , ) + self.outer = outer + + @apply + def outer(): + def fget( self ): + return self._outer + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument outer is mantatory and can not be set to None') + if not check_type(value,ifcclosedshell): + self._outer = ifcclosedshell(value) + else: + self._outer = value + return property(**locals()) + +#################### + # ENTITY ifcfacetedbrep # +#################### +class ifcfacetedbrep(ifcmanifoldsolidbrep): + '''Entity ifcfacetedbrep definition. + ''' + def __init__( self , inherited0__outer , ): + ifcmanifoldsolidbrep.__init__(self , inherited0__outer , ) + +#################### + # ENTITY ifcbooleanresult # +#################### +class ifcbooleanresult(ifcgeometricrepresentationitem): + '''Entity ifcbooleanresult definition. + + :param operator + :type operator:ifcbooleanoperator + + :param firstoperand + :type firstoperand:ifcbooleanoperand + + :param secondoperand + :type secondoperand:ifcbooleanoperand + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , operator,firstoperand,secondoperand, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.operator = operator + self.firstoperand = firstoperand + self.secondoperand = secondoperand + + @apply + def operator(): + def fget( self ): + return self._operator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operator is mantatory and can not be set to None') + if not check_type(value,ifcbooleanoperator): + self._operator = ifcbooleanoperator(value) + else: + self._operator = value + return property(**locals()) + + @apply + def firstoperand(): + def fget( self ): + return self._firstoperand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument firstoperand is mantatory and can not be set to None') + if not check_type(value,ifcbooleanoperand): + self._firstoperand = ifcbooleanoperand(value) + else: + self._firstoperand = value + return property(**locals()) + + @apply + def secondoperand(): + def fget( self ): + return self._secondoperand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument secondoperand is mantatory and can not be set to None') + if not check_type(value,ifcbooleanoperand): + self._secondoperand = ifcbooleanoperand(value) + else: + self._secondoperand = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.firstoperand.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.firstoperand.self.dim == self.secondoperand.self.dim) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcslabtype # +#################### +class ifcslabtype(ifcbuildingelementtype): + '''Entity ifcslabtype definition. + + :param predefinedtype + :type predefinedtype:ifcslabtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcslabtypeenum): + self._predefinedtype = ifcslabtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifctextstyletextmodel # +#################### +class ifctextstyletextmodel(BaseEntityClass): + '''Entity ifctextstyletextmodel definition. + + :param textindent + :type textindent:ifcsizeselect + + :param textalign + :type textalign:ifctextalignment + + :param textdecoration + :type textdecoration:ifctextdecoration + + :param letterspacing + :type letterspacing:ifcsizeselect + + :param wordspacing + :type wordspacing:ifcsizeselect + + :param texttransform + :type texttransform:ifctexttransformation + + :param lineheight + :type lineheight:ifcsizeselect + ''' + def __init__( self , textindent,textalign,textdecoration,letterspacing,wordspacing,texttransform,lineheight, ): + self.textindent = textindent + self.textalign = textalign + self.textdecoration = textdecoration + self.letterspacing = letterspacing + self.wordspacing = wordspacing + self.texttransform = texttransform + self.lineheight = lineheight + + @apply + def textindent(): + def fget( self ): + return self._textindent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._textindent = ifcsizeselect(value) + else: + self._textindent = value + else: + self._textindent = value + return property(**locals()) + + @apply + def textalign(): + def fget( self ): + return self._textalign + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctextalignment): + self._textalign = ifctextalignment(value) + else: + self._textalign = value + else: + self._textalign = value + return property(**locals()) + + @apply + def textdecoration(): + def fget( self ): + return self._textdecoration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctextdecoration): + self._textdecoration = ifctextdecoration(value) + else: + self._textdecoration = value + else: + self._textdecoration = value + return property(**locals()) + + @apply + def letterspacing(): + def fget( self ): + return self._letterspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._letterspacing = ifcsizeselect(value) + else: + self._letterspacing = value + else: + self._letterspacing = value + return property(**locals()) + + @apply + def wordspacing(): + def fget( self ): + return self._wordspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._wordspacing = ifcsizeselect(value) + else: + self._wordspacing = value + else: + self._wordspacing = value + return property(**locals()) + + @apply + def texttransform(): + def fget( self ): + return self._texttransform + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctexttransformation): + self._texttransform = ifctexttransformation(value) + else: + self._texttransform = value + else: + self._texttransform = value + return property(**locals()) + + @apply + def lineheight(): + def fget( self ): + return self._lineheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._lineheight = ifcsizeselect(value) + else: + self._lineheight = value + else: + self._lineheight = value + return property(**locals()) + +#################### + # ENTITY ifcunitassignment # +#################### +class ifcunitassignment(BaseEntityClass): + '''Entity ifcunitassignment definition. + + :param units + :type units:SET(1,None,'ifcunit', scope = schema_scope) + ''' + def __init__( self , units, ): + self.units = units + + @apply + def units(): + def fget( self ): + return self._units + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument units is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcunit', scope = schema_scope)): + self._units = SET(value) + else: + self._units = value + return property(**locals()) + def wr01(self): + eval_wr01_wr = ifccorrectunitassignment(self.units) + if not eval_wr01_wr: + raise AssertionError('Rule wr01 violated') + else: + return eval_wr01_wr + + +#################### + # ENTITY ifcbeam # +#################### +class ifcbeam(ifcbuildingelement): + '''Entity ifcbeam definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcevaporativecoolertype # +#################### +class ifcevaporativecoolertype(ifcenergyconversiondevicetype): + '''Entity ifcevaporativecoolertype definition. + + :param predefinedtype + :type predefinedtype:ifcevaporativecoolertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcevaporativecoolertypeenum): + self._predefinedtype = ifcevaporativecoolertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcevaporativecoolertypeenum.self.userdefined) or ((self.predefinedtype == ifcevaporativecoolertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcelementarysurface # +#################### +class ifcelementarysurface(ifcsurface): + '''Entity ifcelementarysurface definition. + + :param position + :type position:ifcaxis2placement3d + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , position, ): + ifcsurface.__init__(self , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.position.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcalarmtype # +#################### +class ifcalarmtype(ifcdistributioncontrolelementtype): + '''Entity ifcalarmtype definition. + + :param predefinedtype + :type predefinedtype:ifcalarmtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcalarmtypeenum): + self._predefinedtype = ifcalarmtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcmembertype # +#################### +class ifcmembertype(ifcbuildingelementtype): + '''Entity ifcmembertype definition. + + :param predefinedtype + :type predefinedtype:ifcmembertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcmembertypeenum): + self._predefinedtype = ifcmembertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcrelflowcontrolelements # +#################### +class ifcrelflowcontrolelements(ifcrelconnects): + '''Entity ifcrelflowcontrolelements definition. + + :param relatedcontrolelements + :type relatedcontrolelements:SET(1,None,'ifcdistributioncontrolelement', scope = schema_scope) + + :param relatingflowelement + :type relatingflowelement:ifcdistributionflowelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedcontrolelements,relatingflowelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedcontrolelements = relatedcontrolelements + self.relatingflowelement = relatingflowelement + + @apply + def relatedcontrolelements(): + def fget( self ): + return self._relatedcontrolelements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedcontrolelements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcdistributioncontrolelement', scope = schema_scope)): + self._relatedcontrolelements = SET(value) + else: + self._relatedcontrolelements = value + return property(**locals()) + + @apply + def relatingflowelement(): + def fget( self ): + return self._relatingflowelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingflowelement is mantatory and can not be set to None') + if not check_type(value,ifcdistributionflowelement): + self._relatingflowelement = ifcdistributionflowelement(value) + else: + self._relatingflowelement = value + return property(**locals()) + +#################### + # ENTITY ifcvertexbasedtexturemap # +#################### +class ifcvertexbasedtexturemap(BaseEntityClass): + '''Entity ifcvertexbasedtexturemap definition. + + :param texturevertices + :type texturevertices:LIST(3,None,'ifctexturevertex', scope = schema_scope) + + :param texturepoints + :type texturepoints:LIST(3,None,'ifccartesianpoint', scope = schema_scope) + ''' + def __init__( self , texturevertices,texturepoints, ): + self.texturevertices = texturevertices + self.texturepoints = texturepoints + + @apply + def texturevertices(): + def fget( self ): + return self._texturevertices + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument texturevertices is mantatory and can not be set to None') + if not check_type(value,LIST(3,None,'ifctexturevertex', scope = schema_scope)): + self._texturevertices = LIST(value) + else: + self._texturevertices = value + return property(**locals()) + + @apply + def texturepoints(): + def fget( self ): + return self._texturepoints + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument texturepoints is mantatory and can not be set to None') + if not check_type(value,LIST(3,None,'ifccartesianpoint', scope = schema_scope)): + self._texturepoints = LIST(value) + else: + self._texturepoints = value + return property(**locals()) + +#################### + # ENTITY ifcpropertylistvalue # +#################### +class ifcpropertylistvalue(ifcsimpleproperty): + '''Entity ifcpropertylistvalue definition. + + :param listvalues + :type listvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param unit + :type unit:ifcunit + ''' + def __init__( self , inherited0__name , inherited1__description , listvalues,unit, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.listvalues = listvalues + self.unit = unit + + @apply + def listvalues(): + def fget( self ): + return self._listvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument listvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._listvalues = LIST(value) + else: + self._listvalues = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (SIZEOF(None) == 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcstructuralactivity # +#################### +class ifcstructuralactivity(ifcproduct): + '''Entity ifcstructuralactivity definition. + + :param appliedload + :type appliedload:ifcstructuralload + + :param globalorlocal + :type globalorlocal:ifcglobalorlocalenum + + :param assignedtostructuralitem + :type assignedtostructuralitem:ifcrelconnectsstructuralactivity + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , appliedload,globalorlocal, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.appliedload = appliedload + self.globalorlocal = globalorlocal + + @apply + def appliedload(): + def fget( self ): + return self._appliedload + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument appliedload is mantatory and can not be set to None') + if not check_type(value,ifcstructuralload): + self._appliedload = ifcstructuralload(value) + else: + self._appliedload = value + return property(**locals()) + + @apply + def globalorlocal(): + def fget( self ): + return self._globalorlocal + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument globalorlocal is mantatory and can not be set to None') + if not check_type(value,ifcglobalorlocalenum): + self._globalorlocal = ifcglobalorlocalenum(value) + else: + self._globalorlocal = value + return property(**locals()) + + @apply + def assignedtostructuralitem(): + def fget( self ): + return self._assignedtostructuralitem + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument assignedtostructuralitem is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructuralaction # +#################### +class ifcstructuralaction(ifcstructuralactivity): + '''Entity ifcstructuralaction definition. + + :param destabilizingload + :type destabilizingload:BOOLEAN + + :param causedby + :type causedby:ifcstructuralreaction + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , destabilizingload,causedby, ): + ifcstructuralactivity.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ) + self.destabilizingload = destabilizingload + self.causedby = causedby + + @apply + def destabilizingload(): + def fget( self ): + return self._destabilizingload + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument destabilizingload is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._destabilizingload = BOOLEAN(value) + else: + self._destabilizingload = value + return property(**locals()) + + @apply + def causedby(): + def fget( self ): + return self._causedby + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstructuralreaction): + self._causedby = ifcstructuralreaction(value) + else: + self._causedby = value + else: + self._causedby = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacestylerefraction # +#################### +class ifcsurfacestylerefraction(BaseEntityClass): + '''Entity ifcsurfacestylerefraction definition. + + :param refractionindex + :type refractionindex:ifcreal + + :param dispersionfactor + :type dispersionfactor:ifcreal + ''' + def __init__( self , refractionindex,dispersionfactor, ): + self.refractionindex = refractionindex + self.dispersionfactor = dispersionfactor + + @apply + def refractionindex(): + def fget( self ): + return self._refractionindex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreal): + self._refractionindex = ifcreal(value) + else: + self._refractionindex = value + else: + self._refractionindex = value + return property(**locals()) + + @apply + def dispersionfactor(): + def fget( self ): + return self._dispersionfactor + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreal): + self._dispersionfactor = ifcreal(value) + else: + self._dispersionfactor = value + else: + self._dispersionfactor = value + return property(**locals()) + +#################### + # ENTITY ifcpredefinedcurvefont # +#################### +class ifcpredefinedcurvefont(ifcpredefineditem): + '''Entity ifcpredefinedcurvefont definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefineditem.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcrampflight # +#################### +class ifcrampflight(ifcbuildingelement): + '''Entity ifcrampflight definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcdiscreteaccessory # +#################### +class ifcdiscreteaccessory(ifcelementcomponent): + '''Entity ifcdiscreteaccessory definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcperson # +#################### +class ifcperson(BaseEntityClass): + '''Entity ifcperson definition. + + :param id + :type id:ifcidentifier + + :param familyname + :type familyname:ifclabel + + :param givenname + :type givenname:ifclabel + + :param middlenames + :type middlenames:LIST(1,None,'STRING', scope = schema_scope) + + :param prefixtitles + :type prefixtitles:LIST(1,None,'STRING', scope = schema_scope) + + :param suffixtitles + :type suffixtitles:LIST(1,None,'STRING', scope = schema_scope) + + :param roles + :type roles:LIST(1,None,'ifcactorrole', scope = schema_scope) + + :param addresses + :type addresses:LIST(1,None,'ifcaddress', scope = schema_scope) + + :param engagedin + :type engagedin:SET(0,None,'ifcpersonandorganization', scope = schema_scope) + ''' + def __init__( self , id,familyname,givenname,middlenames,prefixtitles,suffixtitles,roles,addresses, ): + self.id = id + self.familyname = familyname + self.givenname = givenname + self.middlenames = middlenames + self.prefixtitles = prefixtitles + self.suffixtitles = suffixtitles + self.roles = roles + self.addresses = addresses + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._id = ifcidentifier(value) + else: + self._id = value + else: + self._id = value + return property(**locals()) + + @apply + def familyname(): + def fget( self ): + return self._familyname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._familyname = ifclabel(value) + else: + self._familyname = value + else: + self._familyname = value + return property(**locals()) + + @apply + def givenname(): + def fget( self ): + return self._givenname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._givenname = ifclabel(value) + else: + self._givenname = value + else: + self._givenname = value + return property(**locals()) + + @apply + def middlenames(): + def fget( self ): + return self._middlenames + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._middlenames = LIST(value) + else: + self._middlenames = value + else: + self._middlenames = value + return property(**locals()) + + @apply + def prefixtitles(): + def fget( self ): + return self._prefixtitles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._prefixtitles = LIST(value) + else: + self._prefixtitles = value + else: + self._prefixtitles = value + return property(**locals()) + + @apply + def suffixtitles(): + def fget( self ): + return self._suffixtitles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._suffixtitles = LIST(value) + else: + self._suffixtitles = value + else: + self._suffixtitles = value + return property(**locals()) + + @apply + def roles(): + def fget( self ): + return self._roles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcactorrole', scope = schema_scope)): + self._roles = LIST(value) + else: + self._roles = value + else: + self._roles = value + return property(**locals()) + + @apply + def addresses(): + def fget( self ): + return self._addresses + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcaddress', scope = schema_scope)): + self._addresses = LIST(value) + else: + self._addresses = value + else: + self._addresses = value + return property(**locals()) + + @apply + def engagedin(): + def fget( self ): + return self._engagedin + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument engagedin is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (EXISTS(self.familyname) or EXISTS(self.givenname)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcairterminaltype # +#################### +class ifcairterminaltype(ifcflowterminaltype): + '''Entity ifcairterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcairterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcairterminaltypeenum): + self._predefinedtype = ifcairterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcairterminaltypeenum.self.userdefined) or ((self.predefinedtype == ifcairterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcfacebound # +#################### +class ifcfacebound(ifctopologicalrepresentationitem): + '''Entity ifcfacebound definition. + + :param bound + :type bound:ifcloop + + :param orientation + :type orientation:BOOLEAN + ''' + def __init__( self , bound,orientation, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.bound = bound + self.orientation = orientation + + @apply + def bound(): + def fget( self ): + return self._bound + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bound is mantatory and can not be set to None') + if not check_type(value,ifcloop): + self._bound = ifcloop(value) + else: + self._bound = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + +#################### + # ENTITY ifcclassificationnotation # +#################### +class ifcclassificationnotation(BaseEntityClass): + '''Entity ifcclassificationnotation definition. + + :param notationfacets + :type notationfacets:SET(1,None,'ifcclassificationnotationfacet', scope = schema_scope) + ''' + def __init__( self , notationfacets, ): + self.notationfacets = notationfacets + + @apply + def notationfacets(): + def fget( self ): + return self._notationfacets + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument notationfacets is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcclassificationnotationfacet', scope = schema_scope)): + self._notationfacets = SET(value) + else: + self._notationfacets = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacestylelighting # +#################### +class ifcsurfacestylelighting(BaseEntityClass): + '''Entity ifcsurfacestylelighting definition. + + :param diffusetransmissioncolour + :type diffusetransmissioncolour:ifccolourrgb + + :param diffusereflectioncolour + :type diffusereflectioncolour:ifccolourrgb + + :param transmissioncolour + :type transmissioncolour:ifccolourrgb + + :param reflectancecolour + :type reflectancecolour:ifccolourrgb + ''' + def __init__( self , diffusetransmissioncolour,diffusereflectioncolour,transmissioncolour,reflectancecolour, ): + self.diffusetransmissioncolour = diffusetransmissioncolour + self.diffusereflectioncolour = diffusereflectioncolour + self.transmissioncolour = transmissioncolour + self.reflectancecolour = reflectancecolour + + @apply + def diffusetransmissioncolour(): + def fget( self ): + return self._diffusetransmissioncolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument diffusetransmissioncolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._diffusetransmissioncolour = ifccolourrgb(value) + else: + self._diffusetransmissioncolour = value + return property(**locals()) + + @apply + def diffusereflectioncolour(): + def fget( self ): + return self._diffusereflectioncolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument diffusereflectioncolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._diffusereflectioncolour = ifccolourrgb(value) + else: + self._diffusereflectioncolour = value + return property(**locals()) + + @apply + def transmissioncolour(): + def fget( self ): + return self._transmissioncolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transmissioncolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._transmissioncolour = ifccolourrgb(value) + else: + self._transmissioncolour = value + return property(**locals()) + + @apply + def reflectancecolour(): + def fget( self ): + return self._reflectancecolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reflectancecolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._reflectancecolour = ifccolourrgb(value) + else: + self._reflectancecolour = value + return property(**locals()) + +#################### + # ENTITY ifctendon # +#################### +class ifctendon(ifcreinforcingelement): + '''Entity ifctendon definition. + + :param predefinedtype + :type predefinedtype:ifctendontypeenum + + :param nominaldiameter + :type nominaldiameter:ifcpositivelengthmeasure + + :param crosssectionarea + :type crosssectionarea:ifcareameasure + + :param tensionforce + :type tensionforce:ifcforcemeasure + + :param prestress + :type prestress:ifcpressuremeasure + + :param frictioncoefficient + :type frictioncoefficient:ifcnormalisedratiomeasure + + :param anchorageslip + :type anchorageslip:ifcpositivelengthmeasure + + :param mincurvatureradius + :type mincurvatureradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , predefinedtype,nominaldiameter,crosssectionarea,tensionforce,prestress,frictioncoefficient,anchorageslip,mincurvatureradius, ): + ifcreinforcingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , ) + self.predefinedtype = predefinedtype + self.nominaldiameter = nominaldiameter + self.crosssectionarea = crosssectionarea + self.tensionforce = tensionforce + self.prestress = prestress + self.frictioncoefficient = frictioncoefficient + self.anchorageslip = anchorageslip + self.mincurvatureradius = mincurvatureradius + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctendontypeenum): + self._predefinedtype = ifctendontypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def nominaldiameter(): + def fget( self ): + return self._nominaldiameter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument nominaldiameter is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._nominaldiameter = ifcpositivelengthmeasure(value) + else: + self._nominaldiameter = value + return property(**locals()) + + @apply + def crosssectionarea(): + def fget( self ): + return self._crosssectionarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument crosssectionarea is mantatory and can not be set to None') + if not check_type(value,ifcareameasure): + self._crosssectionarea = ifcareameasure(value) + else: + self._crosssectionarea = value + return property(**locals()) + + @apply + def tensionforce(): + def fget( self ): + return self._tensionforce + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._tensionforce = ifcforcemeasure(value) + else: + self._tensionforce = value + else: + self._tensionforce = value + return property(**locals()) + + @apply + def prestress(): + def fget( self ): + return self._prestress + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpressuremeasure): + self._prestress = ifcpressuremeasure(value) + else: + self._prestress = value + else: + self._prestress = value + return property(**locals()) + + @apply + def frictioncoefficient(): + def fget( self ): + return self._frictioncoefficient + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._frictioncoefficient = ifcnormalisedratiomeasure(value) + else: + self._frictioncoefficient = value + else: + self._frictioncoefficient = value + return property(**locals()) + + @apply + def anchorageslip(): + def fget( self ): + return self._anchorageslip + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._anchorageslip = ifcpositivelengthmeasure(value) + else: + self._anchorageslip = value + else: + self._anchorageslip = value + return property(**locals()) + + @apply + def mincurvatureradius(): + def fget( self ): + return self._mincurvatureradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._mincurvatureradius = ifcpositivelengthmeasure(value) + else: + self._mincurvatureradius = value + else: + self._mincurvatureradius = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifctendontypeenum.self.userdefined) or ((self.predefinedtype == ifctendontypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcownerhistory # +#################### +class ifcownerhistory(BaseEntityClass): + '''Entity ifcownerhistory definition. + + :param owninguser + :type owninguser:ifcpersonandorganization + + :param owningapplication + :type owningapplication:ifcapplication + + :param state + :type state:ifcstateenum + + :param changeaction + :type changeaction:ifcchangeactionenum + + :param lastmodifieddate + :type lastmodifieddate:ifctimestamp + + :param lastmodifyinguser + :type lastmodifyinguser:ifcpersonandorganization + + :param lastmodifyingapplication + :type lastmodifyingapplication:ifcapplication + + :param creationdate + :type creationdate:ifctimestamp + ''' + def __init__( self , owninguser,owningapplication,state,changeaction,lastmodifieddate,lastmodifyinguser,lastmodifyingapplication,creationdate, ): + self.owninguser = owninguser + self.owningapplication = owningapplication + self.state = state + self.changeaction = changeaction + self.lastmodifieddate = lastmodifieddate + self.lastmodifyinguser = lastmodifyinguser + self.lastmodifyingapplication = lastmodifyingapplication + self.creationdate = creationdate + + @apply + def owninguser(): + def fget( self ): + return self._owninguser + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument owninguser is mantatory and can not be set to None') + if not check_type(value,ifcpersonandorganization): + self._owninguser = ifcpersonandorganization(value) + else: + self._owninguser = value + return property(**locals()) + + @apply + def owningapplication(): + def fget( self ): + return self._owningapplication + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument owningapplication is mantatory and can not be set to None') + if not check_type(value,ifcapplication): + self._owningapplication = ifcapplication(value) + else: + self._owningapplication = value + return property(**locals()) + + @apply + def state(): + def fget( self ): + return self._state + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstateenum): + self._state = ifcstateenum(value) + else: + self._state = value + else: + self._state = value + return property(**locals()) + + @apply + def changeaction(): + def fget( self ): + return self._changeaction + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument changeaction is mantatory and can not be set to None') + if not check_type(value,ifcchangeactionenum): + self._changeaction = ifcchangeactionenum(value) + else: + self._changeaction = value + return property(**locals()) + + @apply + def lastmodifieddate(): + def fget( self ): + return self._lastmodifieddate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimestamp): + self._lastmodifieddate = ifctimestamp(value) + else: + self._lastmodifieddate = value + else: + self._lastmodifieddate = value + return property(**locals()) + + @apply + def lastmodifyinguser(): + def fget( self ): + return self._lastmodifyinguser + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpersonandorganization): + self._lastmodifyinguser = ifcpersonandorganization(value) + else: + self._lastmodifyinguser = value + else: + self._lastmodifyinguser = value + return property(**locals()) + + @apply + def lastmodifyingapplication(): + def fget( self ): + return self._lastmodifyingapplication + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcapplication): + self._lastmodifyingapplication = ifcapplication(value) + else: + self._lastmodifyingapplication = value + else: + self._lastmodifyingapplication = value + return property(**locals()) + + @apply + def creationdate(): + def fget( self ): + return self._creationdate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument creationdate is mantatory and can not be set to None') + if not check_type(value,ifctimestamp): + self._creationdate = ifctimestamp(value) + else: + self._creationdate = value + return property(**locals()) + +#################### + # ENTITY ifcservicelife # +#################### +class ifcservicelife(ifccontrol): + '''Entity ifcservicelife definition. + + :param servicelifetype + :type servicelifetype:ifcservicelifetypeenum + + :param servicelifeduration + :type servicelifeduration:ifctimemeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , servicelifetype,servicelifeduration, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.servicelifetype = servicelifetype + self.servicelifeduration = servicelifeduration + + @apply + def servicelifetype(): + def fget( self ): + return self._servicelifetype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument servicelifetype is mantatory and can not be set to None') + if not check_type(value,ifcservicelifetypeenum): + self._servicelifetype = ifcservicelifetypeenum(value) + else: + self._servicelifetype = value + return property(**locals()) + + @apply + def servicelifeduration(): + def fget( self ): + return self._servicelifeduration + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument servicelifeduration is mantatory and can not be set to None') + if not check_type(value,ifctimemeasure): + self._servicelifeduration = ifctimemeasure(value) + else: + self._servicelifeduration = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacestylewithtextures # +#################### +class ifcsurfacestylewithtextures(BaseEntityClass): + '''Entity ifcsurfacestylewithtextures definition. + + :param textures + :type textures:LIST(1,None,'ifcsurfacetexture', scope = schema_scope) + ''' + def __init__( self , textures, ): + self.textures = textures + + @apply + def textures(): + def fget( self ): + return self._textures + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument textures is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcsurfacetexture', scope = schema_scope)): + self._textures = LIST(value) + else: + self._textures = value + return property(**locals()) + +#################### + # ENTITY ifcproject # +#################### +class ifcproject(ifcobject): + '''Entity ifcproject definition. + + :param longname + :type longname:ifclabel + + :param phase + :type phase:ifclabel + + :param representationcontexts + :type representationcontexts:SET(1,None,'ifcrepresentationcontext', scope = schema_scope) + + :param unitsincontext + :type unitsincontext:ifcunitassignment + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , longname,phase,representationcontexts,unitsincontext, ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.longname = longname + self.phase = phase + self.representationcontexts = representationcontexts + self.unitsincontext = unitsincontext + + @apply + def longname(): + def fget( self ): + return self._longname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._longname = ifclabel(value) + else: + self._longname = value + else: + self._longname = value + return property(**locals()) + + @apply + def phase(): + def fget( self ): + return self._phase + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._phase = ifclabel(value) + else: + self._phase = value + else: + self._phase = value + return property(**locals()) + + @apply + def representationcontexts(): + def fget( self ): + return self._representationcontexts + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representationcontexts is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcrepresentationcontext', scope = schema_scope)): + self._representationcontexts = SET(value) + else: + self._representationcontexts = value + return property(**locals()) + + @apply + def unitsincontext(): + def fget( self ): + return self._unitsincontext + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unitsincontext is mantatory and can not be set to None') + if not check_type(value,ifcunitassignment): + self._unitsincontext = ifcunitassignment(value) + else: + self._unitsincontext = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = (SIZEOF(None) == 0) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + def wr33(self): + eval_wr33_wr = (SIZEOF(self.self.ifcobjectdefinition.self.decomposes) == 0) + if not eval_wr33_wr: + raise AssertionError('Rule wr33 violated') + else: + return eval_wr33_wr + + +#################### + # ENTITY ifcflowstoragedevicetype # +#################### +class ifcflowstoragedevicetype(ifcdistributionflowelementtype): + '''Entity ifcflowstoragedevicetype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcelectricflowstoragedevicetype # +#################### +class ifcelectricflowstoragedevicetype(ifcflowstoragedevicetype): + '''Entity ifcelectricflowstoragedevicetype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricflowstoragedevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowstoragedevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricflowstoragedevicetypeenum): + self._predefinedtype = ifcelectricflowstoragedevicetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcplane # +#################### +class ifcplane(ifcelementarysurface): + '''Entity ifcplane definition. + ''' + def __init__( self , inherited0__position , ): + ifcelementarysurface.__init__(self , inherited0__position , ) + +#################### + # ENTITY ifccolourspecification # +#################### +class ifccolourspecification(BaseEntityClass): + '''Entity ifccolourspecification definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifccolourrgb # +#################### +class ifccolourrgb(ifccolourspecification): + '''Entity ifccolourrgb definition. + + :param red + :type red:ifcnormalisedratiomeasure + + :param green + :type green:ifcnormalisedratiomeasure + + :param blue + :type blue:ifcnormalisedratiomeasure + ''' + def __init__( self , inherited0__name , red,green,blue, ): + ifccolourspecification.__init__(self , inherited0__name , ) + self.red = red + self.green = green + self.blue = blue + + @apply + def red(): + def fget( self ): + return self._red + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument red is mantatory and can not be set to None') + if not check_type(value,ifcnormalisedratiomeasure): + self._red = ifcnormalisedratiomeasure(value) + else: + self._red = value + return property(**locals()) + + @apply + def green(): + def fget( self ): + return self._green + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument green is mantatory and can not be set to None') + if not check_type(value,ifcnormalisedratiomeasure): + self._green = ifcnormalisedratiomeasure(value) + else: + self._green = value + return property(**locals()) + + @apply + def blue(): + def fget( self ): + return self._blue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument blue is mantatory and can not be set to None') + if not check_type(value,ifcnormalisedratiomeasure): + self._blue = ifcnormalisedratiomeasure(value) + else: + self._blue = value + return property(**locals()) + +#################### + # ENTITY ifcfluidflowproperties # +#################### +class ifcfluidflowproperties(ifcpropertysetdefinition): + '''Entity ifcfluidflowproperties definition. + + :param propertysource + :type propertysource:ifcpropertysourceenum + + :param flowconditiontimeseries + :type flowconditiontimeseries:ifctimeseries + + :param velocitytimeseries + :type velocitytimeseries:ifctimeseries + + :param flowratetimeseries + :type flowratetimeseries:ifctimeseries + + :param fluid + :type fluid:ifcmaterial + + :param pressuretimeseries + :type pressuretimeseries:ifctimeseries + + :param userdefinedpropertysource + :type userdefinedpropertysource:ifclabel + + :param temperaturesinglevalue + :type temperaturesinglevalue:ifcthermodynamictemperaturemeasure + + :param wetbulbtemperaturesinglevalue + :type wetbulbtemperaturesinglevalue:ifcthermodynamictemperaturemeasure + + :param wetbulbtemperaturetimeseries + :type wetbulbtemperaturetimeseries:ifctimeseries + + :param temperaturetimeseries + :type temperaturetimeseries:ifctimeseries + + :param flowratesinglevalue + :type flowratesinglevalue:ifcderivedmeasurevalue + + :param flowconditionsinglevalue + :type flowconditionsinglevalue:ifcpositiveratiomeasure + + :param velocitysinglevalue + :type velocitysinglevalue:ifclinearvelocitymeasure + + :param pressuresinglevalue + :type pressuresinglevalue:ifcpressuremeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , propertysource,flowconditiontimeseries,velocitytimeseries,flowratetimeseries,fluid,pressuretimeseries,userdefinedpropertysource,temperaturesinglevalue,wetbulbtemperaturesinglevalue,wetbulbtemperaturetimeseries,temperaturetimeseries,flowratesinglevalue,flowconditionsinglevalue,velocitysinglevalue,pressuresinglevalue, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.propertysource = propertysource + self.flowconditiontimeseries = flowconditiontimeseries + self.velocitytimeseries = velocitytimeseries + self.flowratetimeseries = flowratetimeseries + self.fluid = fluid + self.pressuretimeseries = pressuretimeseries + self.userdefinedpropertysource = userdefinedpropertysource + self.temperaturesinglevalue = temperaturesinglevalue + self.wetbulbtemperaturesinglevalue = wetbulbtemperaturesinglevalue + self.wetbulbtemperaturetimeseries = wetbulbtemperaturetimeseries + self.temperaturetimeseries = temperaturetimeseries + self.flowratesinglevalue = flowratesinglevalue + self.flowconditionsinglevalue = flowconditionsinglevalue + self.velocitysinglevalue = velocitysinglevalue + self.pressuresinglevalue = pressuresinglevalue + + @apply + def propertysource(): + def fget( self ): + return self._propertysource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument propertysource is mantatory and can not be set to None') + if not check_type(value,ifcpropertysourceenum): + self._propertysource = ifcpropertysourceenum(value) + else: + self._propertysource = value + return property(**locals()) + + @apply + def flowconditiontimeseries(): + def fget( self ): + return self._flowconditiontimeseries + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimeseries): + self._flowconditiontimeseries = ifctimeseries(value) + else: + self._flowconditiontimeseries = value + else: + self._flowconditiontimeseries = value + return property(**locals()) + + @apply + def velocitytimeseries(): + def fget( self ): + return self._velocitytimeseries + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimeseries): + self._velocitytimeseries = ifctimeseries(value) + else: + self._velocitytimeseries = value + else: + self._velocitytimeseries = value + return property(**locals()) + + @apply + def flowratetimeseries(): + def fget( self ): + return self._flowratetimeseries + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimeseries): + self._flowratetimeseries = ifctimeseries(value) + else: + self._flowratetimeseries = value + else: + self._flowratetimeseries = value + return property(**locals()) + + @apply + def fluid(): + def fget( self ): + return self._fluid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fluid is mantatory and can not be set to None') + if not check_type(value,ifcmaterial): + self._fluid = ifcmaterial(value) + else: + self._fluid = value + return property(**locals()) + + @apply + def pressuretimeseries(): + def fget( self ): + return self._pressuretimeseries + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimeseries): + self._pressuretimeseries = ifctimeseries(value) + else: + self._pressuretimeseries = value + else: + self._pressuretimeseries = value + return property(**locals()) + + @apply + def userdefinedpropertysource(): + def fget( self ): + return self._userdefinedpropertysource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedpropertysource = ifclabel(value) + else: + self._userdefinedpropertysource = value + else: + self._userdefinedpropertysource = value + return property(**locals()) + + @apply + def temperaturesinglevalue(): + def fget( self ): + return self._temperaturesinglevalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._temperaturesinglevalue = ifcthermodynamictemperaturemeasure(value) + else: + self._temperaturesinglevalue = value + else: + self._temperaturesinglevalue = value + return property(**locals()) + + @apply + def wetbulbtemperaturesinglevalue(): + def fget( self ): + return self._wetbulbtemperaturesinglevalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._wetbulbtemperaturesinglevalue = ifcthermodynamictemperaturemeasure(value) + else: + self._wetbulbtemperaturesinglevalue = value + else: + self._wetbulbtemperaturesinglevalue = value + return property(**locals()) + + @apply + def wetbulbtemperaturetimeseries(): + def fget( self ): + return self._wetbulbtemperaturetimeseries + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimeseries): + self._wetbulbtemperaturetimeseries = ifctimeseries(value) + else: + self._wetbulbtemperaturetimeseries = value + else: + self._wetbulbtemperaturetimeseries = value + return property(**locals()) + + @apply + def temperaturetimeseries(): + def fget( self ): + return self._temperaturetimeseries + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimeseries): + self._temperaturetimeseries = ifctimeseries(value) + else: + self._temperaturetimeseries = value + else: + self._temperaturetimeseries = value + return property(**locals()) + + @apply + def flowratesinglevalue(): + def fget( self ): + return self._flowratesinglevalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcderivedmeasurevalue): + self._flowratesinglevalue = ifcderivedmeasurevalue(value) + else: + self._flowratesinglevalue = value + else: + self._flowratesinglevalue = value + return property(**locals()) + + @apply + def flowconditionsinglevalue(): + def fget( self ): + return self._flowconditionsinglevalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._flowconditionsinglevalue = ifcpositiveratiomeasure(value) + else: + self._flowconditionsinglevalue = value + else: + self._flowconditionsinglevalue = value + return property(**locals()) + + @apply + def velocitysinglevalue(): + def fget( self ): + return self._velocitysinglevalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearvelocitymeasure): + self._velocitysinglevalue = ifclinearvelocitymeasure(value) + else: + self._velocitysinglevalue = value + else: + self._velocitysinglevalue = value + return property(**locals()) + + @apply + def pressuresinglevalue(): + def fget( self ): + return self._pressuresinglevalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpressuremeasure): + self._pressuresinglevalue = ifcpressuremeasure(value) + else: + self._pressuresinglevalue = value + else: + self._pressuresinglevalue = value + return property(**locals()) + +#################### + # ENTITY ifcreinforcingbar # +#################### +class ifcreinforcingbar(ifcreinforcingelement): + '''Entity ifcreinforcingbar definition. + + :param nominaldiameter + :type nominaldiameter:ifcpositivelengthmeasure + + :param crosssectionarea + :type crosssectionarea:ifcareameasure + + :param barlength + :type barlength:ifcpositivelengthmeasure + + :param barrole + :type barrole:ifcreinforcingbarroleenum + + :param barsurface + :type barsurface:ifcreinforcingbarsurfaceenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , nominaldiameter,crosssectionarea,barlength,barrole,barsurface, ): + ifcreinforcingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , ) + self.nominaldiameter = nominaldiameter + self.crosssectionarea = crosssectionarea + self.barlength = barlength + self.barrole = barrole + self.barsurface = barsurface + + @apply + def nominaldiameter(): + def fget( self ): + return self._nominaldiameter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument nominaldiameter is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._nominaldiameter = ifcpositivelengthmeasure(value) + else: + self._nominaldiameter = value + return property(**locals()) + + @apply + def crosssectionarea(): + def fget( self ): + return self._crosssectionarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument crosssectionarea is mantatory and can not be set to None') + if not check_type(value,ifcareameasure): + self._crosssectionarea = ifcareameasure(value) + else: + self._crosssectionarea = value + return property(**locals()) + + @apply + def barlength(): + def fget( self ): + return self._barlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._barlength = ifcpositivelengthmeasure(value) + else: + self._barlength = value + else: + self._barlength = value + return property(**locals()) + + @apply + def barrole(): + def fget( self ): + return self._barrole + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument barrole is mantatory and can not be set to None') + if not check_type(value,ifcreinforcingbarroleenum): + self._barrole = ifcreinforcingbarroleenum(value) + else: + self._barrole = value + return property(**locals()) + + @apply + def barsurface(): + def fget( self ): + return self._barsurface + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreinforcingbarsurfaceenum): + self._barsurface = ifcreinforcingbarsurfaceenum(value) + else: + self._barsurface = value + else: + self._barsurface = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.barrole != ifcreinforcingbarroleenum.self.userdefined) or ((self.barrole == ifcreinforcingbarroleenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcpermit # +#################### +class ifcpermit(ifccontrol): + '''Entity ifcpermit definition. + + :param permitid + :type permitid:ifcidentifier + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , permitid, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.permitid = permitid + + @apply + def permitid(): + def fget( self ): + return self._permitid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument permitid is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._permitid = ifcidentifier(value) + else: + self._permitid = value + return property(**locals()) + +#################### + # ENTITY ifcreferencesvaluedocument # +#################### +class ifcreferencesvaluedocument(BaseEntityClass): + '''Entity ifcreferencesvaluedocument definition. + + :param referenceddocument + :type referenceddocument:ifcdocumentselect + + :param referencingvalues + :type referencingvalues:SET(1,None,'ifcappliedvalue', scope = schema_scope) + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + ''' + def __init__( self , referenceddocument,referencingvalues,name,description, ): + self.referenceddocument = referenceddocument + self.referencingvalues = referencingvalues + self.name = name + self.description = description + + @apply + def referenceddocument(): + def fget( self ): + return self._referenceddocument + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument referenceddocument is mantatory and can not be set to None') + if not check_type(value,ifcdocumentselect): + self._referenceddocument = ifcdocumentselect(value) + else: + self._referenceddocument = value + return property(**locals()) + + @apply + def referencingvalues(): + def fget( self ): + return self._referencingvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument referencingvalues is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcappliedvalue', scope = schema_scope)): + self._referencingvalues = SET(value) + else: + self._referencingvalues = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacestyleshading # +#################### +class ifcsurfacestyleshading(BaseEntityClass): + '''Entity ifcsurfacestyleshading definition. + + :param surfacecolour + :type surfacecolour:ifccolourrgb + ''' + def __init__( self , surfacecolour, ): + self.surfacecolour = surfacecolour + + @apply + def surfacecolour(): + def fget( self ): + return self._surfacecolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument surfacecolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._surfacecolour = ifccolourrgb(value) + else: + self._surfacecolour = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacestylerendering # +#################### +class ifcsurfacestylerendering(ifcsurfacestyleshading): + '''Entity ifcsurfacestylerendering definition. + + :param transparency + :type transparency:ifcnormalisedratiomeasure + + :param diffusecolour + :type diffusecolour:ifccolourorfactor + + :param transmissioncolour + :type transmissioncolour:ifccolourorfactor + + :param diffusetransmissioncolour + :type diffusetransmissioncolour:ifccolourorfactor + + :param reflectioncolour + :type reflectioncolour:ifccolourorfactor + + :param specularcolour + :type specularcolour:ifccolourorfactor + + :param specularhighlight + :type specularhighlight:ifcspecularhighlightselect + + :param reflectancemethod + :type reflectancemethod:ifcreflectancemethodenum + ''' + def __init__( self , inherited0__surfacecolour , transparency,diffusecolour,transmissioncolour,diffusetransmissioncolour,reflectioncolour,specularcolour,specularhighlight,reflectancemethod, ): + ifcsurfacestyleshading.__init__(self , inherited0__surfacecolour , ) + self.transparency = transparency + self.diffusecolour = diffusecolour + self.transmissioncolour = transmissioncolour + self.diffusetransmissioncolour = diffusetransmissioncolour + self.reflectioncolour = reflectioncolour + self.specularcolour = specularcolour + self.specularhighlight = specularhighlight + self.reflectancemethod = reflectancemethod + + @apply + def transparency(): + def fget( self ): + return self._transparency + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._transparency = ifcnormalisedratiomeasure(value) + else: + self._transparency = value + else: + self._transparency = value + return property(**locals()) + + @apply + def diffusecolour(): + def fget( self ): + return self._diffusecolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._diffusecolour = ifccolourorfactor(value) + else: + self._diffusecolour = value + else: + self._diffusecolour = value + return property(**locals()) + + @apply + def transmissioncolour(): + def fget( self ): + return self._transmissioncolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._transmissioncolour = ifccolourorfactor(value) + else: + self._transmissioncolour = value + else: + self._transmissioncolour = value + return property(**locals()) + + @apply + def diffusetransmissioncolour(): + def fget( self ): + return self._diffusetransmissioncolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._diffusetransmissioncolour = ifccolourorfactor(value) + else: + self._diffusetransmissioncolour = value + else: + self._diffusetransmissioncolour = value + return property(**locals()) + + @apply + def reflectioncolour(): + def fget( self ): + return self._reflectioncolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._reflectioncolour = ifccolourorfactor(value) + else: + self._reflectioncolour = value + else: + self._reflectioncolour = value + return property(**locals()) + + @apply + def specularcolour(): + def fget( self ): + return self._specularcolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._specularcolour = ifccolourorfactor(value) + else: + self._specularcolour = value + else: + self._specularcolour = value + return property(**locals()) + + @apply + def specularhighlight(): + def fget( self ): + return self._specularhighlight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcspecularhighlightselect): + self._specularhighlight = ifcspecularhighlightselect(value) + else: + self._specularhighlight = value + else: + self._specularhighlight = value + return property(**locals()) + + @apply + def reflectancemethod(): + def fget( self ): + return self._reflectancemethod + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reflectancemethod is mantatory and can not be set to None') + if not check_type(value,ifcreflectancemethodenum): + self._reflectancemethod = ifcreflectancemethodenum(value) + else: + self._reflectancemethod = value + return property(**locals()) + +#################### + # ENTITY ifcelectrictimecontroltype # +#################### +class ifcelectrictimecontroltype(ifcflowcontrollertype): + '''Entity ifcelectrictimecontroltype definition. + + :param predefinedtype + :type predefinedtype:ifcelectrictimecontroltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectrictimecontroltypeenum): + self._predefinedtype = ifcelectrictimecontroltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcstackterminaltype # +#################### +class ifcstackterminaltype(ifcflowterminaltype): + '''Entity ifcstackterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcstackterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstackterminaltypeenum): + self._predefinedtype = ifcstackterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralplanaraction # +#################### +class ifcstructuralplanaraction(ifcstructuralaction): + '''Entity ifcstructuralplanaraction definition. + + :param projectedortrue + :type projectedortrue:ifcprojectedortruelengthenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , projectedortrue, ): + ifcstructuralaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , ) + self.projectedortrue = projectedortrue + + @apply + def projectedortrue(): + def fget( self ): + return self._projectedortrue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument projectedortrue is mantatory and can not be set to None') + if not check_type(value,ifcprojectedortruelengthenum): + self._projectedortrue = ifcprojectedortruelengthenum(value) + else: + self._projectedortrue = value + return property(**locals()) + def wr61(self): + eval_wr61_wr = (SIZEOF(['IFC2X3.IFCSTRUCTURALLOADPLANARFORCE','IFC2X3.IFCSTRUCTURALLOADTEMPERATURE'] * TYPEOF(self.self.ifcstructuralactivity.self.appliedload)) == 1) + if not eval_wr61_wr: + raise AssertionError('Rule wr61 violated') + else: + return eval_wr61_wr + + +#################### + # ENTITY ifcstructuralplanaractionvarying # +#################### +class ifcstructuralplanaractionvarying(ifcstructuralplanaraction): + '''Entity ifcstructuralplanaractionvarying definition. + + :param varyingappliedloadlocation + :type varyingappliedloadlocation:ifcshapeaspect + + :param subsequentappliedloads + :type subsequentappliedloads:LIST(2,None,'ifcstructuralload', scope = schema_scope) + + :param varyingappliedloads + :type varyingappliedloads:LIST(3,None,'ifcstructuralload', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , inherited11__projectedortrue , varyingappliedloadlocation,subsequentappliedloads, ): + ifcstructuralplanaraction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , inherited11__projectedortrue , ) + self.varyingappliedloadlocation = varyingappliedloadlocation + self.subsequentappliedloads = subsequentappliedloads + + @apply + def varyingappliedloadlocation(): + def fget( self ): + return self._varyingappliedloadlocation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument varyingappliedloadlocation is mantatory and can not be set to None') + if not check_type(value,ifcshapeaspect): + self._varyingappliedloadlocation = ifcshapeaspect(value) + else: + self._varyingappliedloadlocation = value + return property(**locals()) + + @apply + def subsequentappliedloads(): + def fget( self ): + return self._subsequentappliedloads + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument subsequentappliedloads is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'ifcstructuralload', scope = schema_scope)): + self._subsequentappliedloads = LIST(value) + else: + self._subsequentappliedloads = value + return property(**locals()) + + @apply + def varyingappliedloads(): + def fget( self ): + attribute_eval = ifcaddtobeginoflist(self.self.ifcstructuralactivity.self.appliedload,self.subsequentappliedloads) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument varyingappliedloads is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcport # +#################### +class ifcport(ifcproduct): + '''Entity ifcport definition. + + :param containedin + :type containedin:ifcrelconnectsporttoelement + + :param connectedfrom + :type connectedfrom:SET(0,1,'ifcrelconnectsports', scope = schema_scope) + + :param connectedto + :type connectedto:SET(0,1,'ifcrelconnectsports', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + + @apply + def containedin(): + def fget( self ): + return self._containedin + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containedin is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def connectedfrom(): + def fget( self ): + return self._connectedfrom + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedfrom is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def connectedto(): + def fget( self ): + return self._connectedto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcchillertype # +#################### +class ifcchillertype(ifcenergyconversiondevicetype): + '''Entity ifcchillertype definition. + + :param predefinedtype + :type predefinedtype:ifcchillertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcchillertypeenum): + self._predefinedtype = ifcchillertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcchillertypeenum.self.userdefined) or ((self.predefinedtype == ifcchillertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccooledbeamtype # +#################### +class ifccooledbeamtype(ifcenergyconversiondevicetype): + '''Entity ifccooledbeamtype definition. + + :param predefinedtype + :type predefinedtype:ifccooledbeamtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccooledbeamtypeenum): + self._predefinedtype = ifccooledbeamtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifccooledbeamtypeenum.self.userdefined) or ((self.predefinedtype == ifccooledbeamtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccranerailfshapeprofiledef # +#################### +class ifccranerailfshapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifccranerailfshapeprofiledef definition. + + :param overallheight + :type overallheight:ifcpositivelengthmeasure + + :param headwidth + :type headwidth:ifcpositivelengthmeasure + + :param radius + :type radius:ifcpositivelengthmeasure + + :param headdepth2 + :type headdepth2:ifcpositivelengthmeasure + + :param headdepth3 + :type headdepth3:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param basedepth1 + :type basedepth1:ifcpositivelengthmeasure + + :param basedepth2 + :type basedepth2:ifcpositivelengthmeasure + + :param centreofgravityiny + :type centreofgravityiny:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , overallheight,headwidth,radius,headdepth2,headdepth3,webthickness,basedepth1,basedepth2,centreofgravityiny, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.overallheight = overallheight + self.headwidth = headwidth + self.radius = radius + self.headdepth2 = headdepth2 + self.headdepth3 = headdepth3 + self.webthickness = webthickness + self.basedepth1 = basedepth1 + self.basedepth2 = basedepth2 + self.centreofgravityiny = centreofgravityiny + + @apply + def overallheight(): + def fget( self ): + return self._overallheight + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument overallheight is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._overallheight = ifcpositivelengthmeasure(value) + else: + self._overallheight = value + return property(**locals()) + + @apply + def headwidth(): + def fget( self ): + return self._headwidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument headwidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._headwidth = ifcpositivelengthmeasure(value) + else: + self._headwidth = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + else: + self._radius = value + return property(**locals()) + + @apply + def headdepth2(): + def fget( self ): + return self._headdepth2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument headdepth2 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._headdepth2 = ifcpositivelengthmeasure(value) + else: + self._headdepth2 = value + return property(**locals()) + + @apply + def headdepth3(): + def fget( self ): + return self._headdepth3 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument headdepth3 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._headdepth3 = ifcpositivelengthmeasure(value) + else: + self._headdepth3 = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def basedepth1(): + def fget( self ): + return self._basedepth1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basedepth1 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._basedepth1 = ifcpositivelengthmeasure(value) + else: + self._basedepth1 = value + return property(**locals()) + + @apply + def basedepth2(): + def fget( self ): + return self._basedepth2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basedepth2 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._basedepth2 = ifcpositivelengthmeasure(value) + else: + self._basedepth2 = value + return property(**locals()) + + @apply + def centreofgravityiny(): + def fget( self ): + return self._centreofgravityiny + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._centreofgravityiny = ifcpositivelengthmeasure(value) + else: + self._centreofgravityiny = value + else: + self._centreofgravityiny = value + return property(**locals()) + +#################### + # ENTITY ifcpersonandorganization # +#################### +class ifcpersonandorganization(BaseEntityClass): + '''Entity ifcpersonandorganization definition. + + :param theperson + :type theperson:ifcperson + + :param theorganization + :type theorganization:ifcorganization + + :param roles + :type roles:LIST(1,None,'ifcactorrole', scope = schema_scope) + ''' + def __init__( self , theperson,theorganization,roles, ): + self.theperson = theperson + self.theorganization = theorganization + self.roles = roles + + @apply + def theperson(): + def fget( self ): + return self._theperson + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument theperson is mantatory and can not be set to None') + if not check_type(value,ifcperson): + self._theperson = ifcperson(value) + else: + self._theperson = value + return property(**locals()) + + @apply + def theorganization(): + def fget( self ): + return self._theorganization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument theorganization is mantatory and can not be set to None') + if not check_type(value,ifcorganization): + self._theorganization = ifcorganization(value) + else: + self._theorganization = value + return property(**locals()) + + @apply + def roles(): + def fget( self ): + return self._roles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcactorrole', scope = schema_scope)): + self._roles = LIST(value) + else: + self._roles = value + else: + self._roles = value + return property(**locals()) + +#################### + # ENTITY ifcpostaladdress # +#################### +class ifcpostaladdress(ifcaddress): + '''Entity ifcpostaladdress definition. + + :param internallocation + :type internallocation:ifclabel + + :param addresslines + :type addresslines:LIST(1,None,'STRING', scope = schema_scope) + + :param postalbox + :type postalbox:ifclabel + + :param town + :type town:ifclabel + + :param region + :type region:ifclabel + + :param postalcode + :type postalcode:ifclabel + + :param country + :type country:ifclabel + ''' + def __init__( self , inherited0__purpose , inherited1__description , inherited2__userdefinedpurpose , internallocation,addresslines,postalbox,town,region,postalcode,country, ): + ifcaddress.__init__(self , inherited0__purpose , inherited1__description , inherited2__userdefinedpurpose , ) + self.internallocation = internallocation + self.addresslines = addresslines + self.postalbox = postalbox + self.town = town + self.region = region + self.postalcode = postalcode + self.country = country + + @apply + def internallocation(): + def fget( self ): + return self._internallocation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._internallocation = ifclabel(value) + else: + self._internallocation = value + else: + self._internallocation = value + return property(**locals()) + + @apply + def addresslines(): + def fget( self ): + return self._addresslines + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._addresslines = LIST(value) + else: + self._addresslines = value + else: + self._addresslines = value + return property(**locals()) + + @apply + def postalbox(): + def fget( self ): + return self._postalbox + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._postalbox = ifclabel(value) + else: + self._postalbox = value + else: + self._postalbox = value + return property(**locals()) + + @apply + def town(): + def fget( self ): + return self._town + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._town = ifclabel(value) + else: + self._town = value + else: + self._town = value + return property(**locals()) + + @apply + def region(): + def fget( self ): + return self._region + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._region = ifclabel(value) + else: + self._region = value + else: + self._region = value + return property(**locals()) + + @apply + def postalcode(): + def fget( self ): + return self._postalcode + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._postalcode = ifclabel(value) + else: + self._postalcode = value + else: + self._postalcode = value + return property(**locals()) + + @apply + def country(): + def fget( self ): + return self._country + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._country = ifclabel(value) + else: + self._country = value + else: + self._country = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((((((EXISTS(self.internallocation) or EXISTS(self.addresslines)) or EXISTS(self.postalbox)) or EXISTS(self.postalcode)) or EXISTS(self.town)) or EXISTS(self.region)) or EXISTS(self.country)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccondition # +#################### +class ifccondition(ifcgroup): + '''Entity ifccondition definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + +#################### + # ENTITY ifcmappeditem # +#################### +class ifcmappeditem(ifcrepresentationitem): + '''Entity ifcmappeditem definition. + + :param mappingsource + :type mappingsource:ifcrepresentationmap + + :param mappingtarget + :type mappingtarget:ifccartesiantransformationoperator + ''' + def __init__( self , mappingsource,mappingtarget, ): + ifcrepresentationitem.__init__(self , ) + self.mappingsource = mappingsource + self.mappingtarget = mappingtarget + + @apply + def mappingsource(): + def fget( self ): + return self._mappingsource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappingsource is mantatory and can not be set to None') + if not check_type(value,ifcrepresentationmap): + self._mappingsource = ifcrepresentationmap(value) + else: + self._mappingsource = value + return property(**locals()) + + @apply + def mappingtarget(): + def fget( self ): + return self._mappingtarget + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappingtarget is mantatory and can not be set to None') + if not check_type(value,ifccartesiantransformationoperator): + self._mappingtarget = ifccartesiantransformationoperator(value) + else: + self._mappingtarget = value + return property(**locals()) + +#################### + # ENTITY ifcmove # +#################### +class ifcmove(ifctask): + '''Entity ifcmove definition. + + :param movefrom + :type movefrom:ifcspatialstructureelement + + :param moveto + :type moveto:ifcspatialstructureelement + + :param punchlist + :type punchlist:LIST(1,None,'STRING', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__taskid , inherited6__status , inherited7__workmethod , inherited8__ismilestone , inherited9__priority , movefrom,moveto,punchlist, ): + ifctask.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__taskid , inherited6__status , inherited7__workmethod , inherited8__ismilestone , inherited9__priority , ) + self.movefrom = movefrom + self.moveto = moveto + self.punchlist = punchlist + + @apply + def movefrom(): + def fget( self ): + return self._movefrom + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument movefrom is mantatory and can not be set to None') + if not check_type(value,ifcspatialstructureelement): + self._movefrom = ifcspatialstructureelement(value) + else: + self._movefrom = value + return property(**locals()) + + @apply + def moveto(): + def fget( self ): + return self._moveto + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument moveto is mantatory and can not be set to None') + if not check_type(value,ifcspatialstructureelement): + self._moveto = ifcspatialstructureelement(value) + else: + self._moveto = value + return property(**locals()) + + @apply + def punchlist(): + def fget( self ): + return self._punchlist + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._punchlist = LIST(value) + else: + self._punchlist = value + else: + self._punchlist = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.ifcprocess.self.operateson) >= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) >= 1) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcoutlettype # +#################### +class ifcoutlettype(ifcflowterminaltype): + '''Entity ifcoutlettype definition. + + :param predefinedtype + :type predefinedtype:ifcoutlettypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcoutlettypeenum): + self._predefinedtype = ifcoutlettypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcconstraintclassificationrelationship # +#################### +class ifcconstraintclassificationrelationship(BaseEntityClass): + '''Entity ifcconstraintclassificationrelationship definition. + + :param classifiedconstraint + :type classifiedconstraint:ifcconstraint + + :param relatedclassifications + :type relatedclassifications:SET(1,None,'ifcclassificationnotationselect', scope = schema_scope) + ''' + def __init__( self , classifiedconstraint,relatedclassifications, ): + self.classifiedconstraint = classifiedconstraint + self.relatedclassifications = relatedclassifications + + @apply + def classifiedconstraint(): + def fget( self ): + return self._classifiedconstraint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument classifiedconstraint is mantatory and can not be set to None') + if not check_type(value,ifcconstraint): + self._classifiedconstraint = ifcconstraint(value) + else: + self._classifiedconstraint = value + return property(**locals()) + + @apply + def relatedclassifications(): + def fget( self ): + return self._relatedclassifications + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedclassifications is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcclassificationnotationselect', scope = schema_scope)): + self._relatedclassifications = SET(value) + else: + self._relatedclassifications = value + return property(**locals()) + +#################### + # ENTITY ifcgeneralmaterialproperties # +#################### +class ifcgeneralmaterialproperties(ifcmaterialproperties): + '''Entity ifcgeneralmaterialproperties definition. + + :param molecularweight + :type molecularweight:ifcmolecularweightmeasure + + :param porosity + :type porosity:ifcnormalisedratiomeasure + + :param massdensity + :type massdensity:ifcmassdensitymeasure + ''' + def __init__( self , inherited0__material , molecularweight,porosity,massdensity, ): + ifcmaterialproperties.__init__(self , inherited0__material , ) + self.molecularweight = molecularweight + self.porosity = porosity + self.massdensity = massdensity + + @apply + def molecularweight(): + def fget( self ): + return self._molecularweight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmolecularweightmeasure): + self._molecularweight = ifcmolecularweightmeasure(value) + else: + self._molecularweight = value + else: + self._molecularweight = value + return property(**locals()) + + @apply + def porosity(): + def fget( self ): + return self._porosity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._porosity = ifcnormalisedratiomeasure(value) + else: + self._porosity = value + else: + self._porosity = value + return property(**locals()) + + @apply + def massdensity(): + def fget( self ): + return self._massdensity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmassdensitymeasure): + self._massdensity = ifcmassdensitymeasure(value) + else: + self._massdensity = value + else: + self._massdensity = value + return property(**locals()) + +#################### + # ENTITY ifcannotationsymboloccurrence # +#################### +class ifcannotationsymboloccurrence(ifcannotationoccurrence): + '''Entity ifcannotationsymboloccurrence definition. + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , ): + ifcannotationoccurrence.__init__(self , inherited0__item , inherited1__styles , inherited2__name , ) + def wr31(self): + eval_wr31_wr = (( not EXISTS(self.self.ifcstyleditem.self.item)) or ('IFC2X3.IFCDEFINEDSYMBOL' == TYPEOF(self.self.ifcstyleditem.self.item))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcterminatorsymbol # +#################### +class ifcterminatorsymbol(ifcannotationsymboloccurrence): + '''Entity ifcterminatorsymbol definition. + + :param annotatedcurve + :type annotatedcurve:ifcannotationcurveoccurrence + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , annotatedcurve, ): + ifcannotationsymboloccurrence.__init__(self , inherited0__item , inherited1__styles , inherited2__name , ) + self.annotatedcurve = annotatedcurve + + @apply + def annotatedcurve(): + def fget( self ): + return self._annotatedcurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument annotatedcurve is mantatory and can not be set to None') + if not check_type(value,ifcannotationcurveoccurrence): + self._annotatedcurve = ifcannotationcurveoccurrence(value) + else: + self._annotatedcurve = value + return property(**locals()) + +#################### + # ENTITY ifcconstraintrelationship # +#################### +class ifcconstraintrelationship(BaseEntityClass): + '''Entity ifcconstraintrelationship definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param relatingconstraint + :type relatingconstraint:ifcconstraint + + :param relatedconstraints + :type relatedconstraints:SET(1,None,'ifcconstraint', scope = schema_scope) + ''' + def __init__( self , name,description,relatingconstraint,relatedconstraints, ): + self.name = name + self.description = description + self.relatingconstraint = relatingconstraint + self.relatedconstraints = relatedconstraints + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relatingconstraint(): + def fget( self ): + return self._relatingconstraint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingconstraint is mantatory and can not be set to None') + if not check_type(value,ifcconstraint): + self._relatingconstraint = ifcconstraint(value) + else: + self._relatingconstraint = value + return property(**locals()) + + @apply + def relatedconstraints(): + def fget( self ): + return self._relatedconstraints + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedconstraints is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcconstraint', scope = schema_scope)): + self._relatedconstraints = SET(value) + else: + self._relatedconstraints = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcpointoncurve # +#################### +class ifcpointoncurve(ifcpoint): + '''Entity ifcpointoncurve definition. + + :param basiscurve + :type basiscurve:ifccurve + + :param pointparameter + :type pointparameter:ifcparametervalue + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , basiscurve,pointparameter, ): + ifcpoint.__init__(self , ) + self.basiscurve = basiscurve + self.pointparameter = pointparameter + + @apply + def basiscurve(): + def fget( self ): + return self._basiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._basiscurve = ifccurve(value) + else: + self._basiscurve = value + return property(**locals()) + + @apply + def pointparameter(): + def fget( self ): + return self._pointparameter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pointparameter is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._pointparameter = ifcparametervalue(value) + else: + self._pointparameter = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.basiscurve.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcrelsequence # +#################### +class ifcrelsequence(ifcrelconnects): + '''Entity ifcrelsequence definition. + + :param relatingprocess + :type relatingprocess:ifcprocess + + :param relatedprocess + :type relatedprocess:ifcprocess + + :param timelag + :type timelag:ifctimemeasure + + :param sequencetype + :type sequencetype:ifcsequenceenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingprocess,relatedprocess,timelag,sequencetype, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingprocess = relatingprocess + self.relatedprocess = relatedprocess + self.timelag = timelag + self.sequencetype = sequencetype + + @apply + def relatingprocess(): + def fget( self ): + return self._relatingprocess + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingprocess is mantatory and can not be set to None') + if not check_type(value,ifcprocess): + self._relatingprocess = ifcprocess(value) + else: + self._relatingprocess = value + return property(**locals()) + + @apply + def relatedprocess(): + def fget( self ): + return self._relatedprocess + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedprocess is mantatory and can not be set to None') + if not check_type(value,ifcprocess): + self._relatedprocess = ifcprocess(value) + else: + self._relatedprocess = value + return property(**locals()) + + @apply + def timelag(): + def fget( self ): + return self._timelag + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timelag is mantatory and can not be set to None') + if not check_type(value,ifctimemeasure): + self._timelag = ifctimemeasure(value) + else: + self._timelag = value + return property(**locals()) + + @apply + def sequencetype(): + def fget( self ): + return self._sequencetype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sequencetype is mantatory and can not be set to None') + if not check_type(value,ifcsequenceenum): + self._sequencetype = ifcsequenceenum(value) + else: + self._sequencetype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.relatingprocess != self.relatedprocess) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcfacetedbrepwithvoids # +#################### +class ifcfacetedbrepwithvoids(ifcmanifoldsolidbrep): + '''Entity ifcfacetedbrepwithvoids definition. + + :param voids + :type voids:SET(1,None,'ifcclosedshell', scope = schema_scope) + ''' + def __init__( self , inherited0__outer , voids, ): + ifcmanifoldsolidbrep.__init__(self , inherited0__outer , ) + self.voids = voids + + @apply + def voids(): + def fget( self ): + return self._voids + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument voids is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcclosedshell', scope = schema_scope)): + self._voids = SET(value) + else: + self._voids = value + return property(**locals()) + +#################### + # ENTITY ifcrelassignstasks # +#################### +class ifcrelassignstasks(ifcrelassignstocontrol): + '''Entity ifcrelassignstasks definition. + + :param timefortask + :type timefortask:ifcscheduletimecontrol + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatingcontrol , timefortask, ): + ifcrelassignstocontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatingcontrol , ) + self.timefortask = timefortask + + @apply + def timefortask(): + def fget( self ): + return self._timefortask + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcscheduletimecontrol): + self._timefortask = ifcscheduletimecontrol(value) + else: + self._timefortask = value + else: + self._timefortask = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (HIINDEX(self.self.ifcrelassigns.self.relatedobjects) == 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('IFC2X3.IFCTASK' == TYPEOF(self.self.ifcrelassigns.self.relatedobjects[1])) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ('IFC2X3.IFCWORKCONTROL' == TYPEOF(self.self.ifcrelassignstocontrol.self.relatingcontrol)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifccoiltype # +#################### +class ifccoiltype(ifcenergyconversiondevicetype): + '''Entity ifccoiltype definition. + + :param predefinedtype + :type predefinedtype:ifccoiltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccoiltypeenum): + self._predefinedtype = ifccoiltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifccoiltypeenum.self.userdefined) or ((self.predefinedtype == ifccoiltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcfurnishingelement # +#################### +class ifcfurnishingelement(ifcelement): + '''Entity ifcfurnishingelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcrelconnectsstructuralmember # +#################### +class ifcrelconnectsstructuralmember(ifcrelconnects): + '''Entity ifcrelconnectsstructuralmember definition. + + :param relatingstructuralmember + :type relatingstructuralmember:ifcstructuralmember + + :param relatedstructuralconnection + :type relatedstructuralconnection:ifcstructuralconnection + + :param appliedcondition + :type appliedcondition:ifcboundarycondition + + :param additionalconditions + :type additionalconditions:ifcstructuralconnectioncondition + + :param supportedlength + :type supportedlength:ifclengthmeasure + + :param conditioncoordinatesystem + :type conditioncoordinatesystem:ifcaxis2placement3d + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingstructuralmember,relatedstructuralconnection,appliedcondition,additionalconditions,supportedlength,conditioncoordinatesystem, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingstructuralmember = relatingstructuralmember + self.relatedstructuralconnection = relatedstructuralconnection + self.appliedcondition = appliedcondition + self.additionalconditions = additionalconditions + self.supportedlength = supportedlength + self.conditioncoordinatesystem = conditioncoordinatesystem + + @apply + def relatingstructuralmember(): + def fget( self ): + return self._relatingstructuralmember + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingstructuralmember is mantatory and can not be set to None') + if not check_type(value,ifcstructuralmember): + self._relatingstructuralmember = ifcstructuralmember(value) + else: + self._relatingstructuralmember = value + return property(**locals()) + + @apply + def relatedstructuralconnection(): + def fget( self ): + return self._relatedstructuralconnection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedstructuralconnection is mantatory and can not be set to None') + if not check_type(value,ifcstructuralconnection): + self._relatedstructuralconnection = ifcstructuralconnection(value) + else: + self._relatedstructuralconnection = value + return property(**locals()) + + @apply + def appliedcondition(): + def fget( self ): + return self._appliedcondition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcboundarycondition): + self._appliedcondition = ifcboundarycondition(value) + else: + self._appliedcondition = value + else: + self._appliedcondition = value + return property(**locals()) + + @apply + def additionalconditions(): + def fget( self ): + return self._additionalconditions + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstructuralconnectioncondition): + self._additionalconditions = ifcstructuralconnectioncondition(value) + else: + self._additionalconditions = value + else: + self._additionalconditions = value + return property(**locals()) + + @apply + def supportedlength(): + def fget( self ): + return self._supportedlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._supportedlength = ifclengthmeasure(value) + else: + self._supportedlength = value + else: + self._supportedlength = value + return property(**locals()) + + @apply + def conditioncoordinatesystem(): + def fget( self ): + return self._conditioncoordinatesystem + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaxis2placement3d): + self._conditioncoordinatesystem = ifcaxis2placement3d(value) + else: + self._conditioncoordinatesystem = value + else: + self._conditioncoordinatesystem = value + return property(**locals()) + +#################### + # ENTITY ifcrelconnectswitheccentricity # +#################### +class ifcrelconnectswitheccentricity(ifcrelconnectsstructuralmember): + '''Entity ifcrelconnectswitheccentricity definition. + + :param connectionconstraint + :type connectionconstraint:ifcconnectiongeometry + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingstructuralmember , inherited5__relatedstructuralconnection , inherited6__appliedcondition , inherited7__additionalconditions , inherited8__supportedlength , inherited9__conditioncoordinatesystem , connectionconstraint, ): + ifcrelconnectsstructuralmember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingstructuralmember , inherited5__relatedstructuralconnection , inherited6__appliedcondition , inherited7__additionalconditions , inherited8__supportedlength , inherited9__conditioncoordinatesystem , ) + self.connectionconstraint = connectionconstraint + + @apply + def connectionconstraint(): + def fget( self ): + return self._connectionconstraint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument connectionconstraint is mantatory and can not be set to None') + if not check_type(value,ifcconnectiongeometry): + self._connectionconstraint = ifcconnectiongeometry(value) + else: + self._connectionconstraint = value + return property(**locals()) + +#################### + # ENTITY ifcrelfillselement # +#################### +class ifcrelfillselement(ifcrelconnects): + '''Entity ifcrelfillselement definition. + + :param relatingopeningelement + :type relatingopeningelement:ifcopeningelement + + :param relatedbuildingelement + :type relatedbuildingelement:ifcelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingopeningelement,relatedbuildingelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingopeningelement = relatingopeningelement + self.relatedbuildingelement = relatedbuildingelement + + @apply + def relatingopeningelement(): + def fget( self ): + return self._relatingopeningelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingopeningelement is mantatory and can not be set to None') + if not check_type(value,ifcopeningelement): + self._relatingopeningelement = ifcopeningelement(value) + else: + self._relatingopeningelement = value + return property(**locals()) + + @apply + def relatedbuildingelement(): + def fget( self ): + return self._relatedbuildingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedbuildingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatedbuildingelement = ifcelement(value) + else: + self._relatedbuildingelement = value + return property(**locals()) + +#################### + # ENTITY ifcrepresentationmap # +#################### +class ifcrepresentationmap(BaseEntityClass): + '''Entity ifcrepresentationmap definition. + + :param mappingorigin + :type mappingorigin:ifcaxis2placement + + :param mappedrepresentation + :type mappedrepresentation:ifcrepresentation + + :param mapusage + :type mapusage:SET(0,None,'ifcmappeditem', scope = schema_scope) + ''' + def __init__( self , mappingorigin,mappedrepresentation, ): + self.mappingorigin = mappingorigin + self.mappedrepresentation = mappedrepresentation + + @apply + def mappingorigin(): + def fget( self ): + return self._mappingorigin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappingorigin is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._mappingorigin = ifcaxis2placement(value) + else: + self._mappingorigin = value + return property(**locals()) + + @apply + def mappedrepresentation(): + def fget( self ): + return self._mappedrepresentation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappedrepresentation is mantatory and can not be set to None') + if not check_type(value,ifcrepresentation): + self._mappedrepresentation = ifcrepresentation(value) + else: + self._mappedrepresentation = value + return property(**locals()) + + @apply + def mapusage(): + def fget( self ): + return self._mapusage + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument mapusage is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructurallinearaction # +#################### +class ifcstructurallinearaction(ifcstructuralaction): + '''Entity ifcstructurallinearaction definition. + + :param projectedortrue + :type projectedortrue:ifcprojectedortruelengthenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , projectedortrue, ): + ifcstructuralaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , ) + self.projectedortrue = projectedortrue + + @apply + def projectedortrue(): + def fget( self ): + return self._projectedortrue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument projectedortrue is mantatory and can not be set to None') + if not check_type(value,ifcprojectedortruelengthenum): + self._projectedortrue = ifcprojectedortruelengthenum(value) + else: + self._projectedortrue = value + return property(**locals()) + def wr61(self): + eval_wr61_wr = (SIZEOF(['IFC2X3.IFCSTRUCTURALLOADLINEARFORCE','IFC2X3.IFCSTRUCTURALLOADTEMPERATURE'] * TYPEOF(self.self.ifcstructuralactivity.self.appliedload)) == 1) + if not eval_wr61_wr: + raise AssertionError('Rule wr61 violated') + else: + return eval_wr61_wr + + +#################### + # ENTITY ifcstructurallinearactionvarying # +#################### +class ifcstructurallinearactionvarying(ifcstructurallinearaction): + '''Entity ifcstructurallinearactionvarying definition. + + :param varyingappliedloadlocation + :type varyingappliedloadlocation:ifcshapeaspect + + :param subsequentappliedloads + :type subsequentappliedloads:LIST(1,None,'ifcstructuralload', scope = schema_scope) + + :param varyingappliedloads + :type varyingappliedloads:LIST(2,None,'ifcstructuralload', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , inherited11__projectedortrue , varyingappliedloadlocation,subsequentappliedloads, ): + ifcstructurallinearaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , inherited11__projectedortrue , ) + self.varyingappliedloadlocation = varyingappliedloadlocation + self.subsequentappliedloads = subsequentappliedloads + + @apply + def varyingappliedloadlocation(): + def fget( self ): + return self._varyingappliedloadlocation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument varyingappliedloadlocation is mantatory and can not be set to None') + if not check_type(value,ifcshapeaspect): + self._varyingappliedloadlocation = ifcshapeaspect(value) + else: + self._varyingappliedloadlocation = value + return property(**locals()) + + @apply + def subsequentappliedloads(): + def fget( self ): + return self._subsequentappliedloads + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument subsequentappliedloads is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcstructuralload', scope = schema_scope)): + self._subsequentappliedloads = LIST(value) + else: + self._subsequentappliedloads = value + return property(**locals()) + + @apply + def varyingappliedloads(): + def fget( self ): + attribute_eval = ifcaddtobeginoflist(self.self.ifcstructuralactivity.self.appliedload,self.subsequentappliedloads) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument varyingappliedloads is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcflowcontroller # +#################### +class ifcflowcontroller(ifcdistributionflowelement): + '''Entity ifcflowcontroller definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcvirtualgridintersection # +#################### +class ifcvirtualgridintersection(BaseEntityClass): + '''Entity ifcvirtualgridintersection definition. + + :param intersectingaxes + :type intersectingaxes:LIST(2,2,'ifcgridaxis', scope = schema_scope) + + :param offsetdistances + :type offsetdistances:LIST(2,3,'REAL', scope = schema_scope) + ''' + def __init__( self , intersectingaxes,offsetdistances, ): + self.intersectingaxes = intersectingaxes + self.offsetdistances = offsetdistances + + @apply + def intersectingaxes(): + def fget( self ): + return self._intersectingaxes + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument intersectingaxes is mantatory and can not be set to None') + if not check_type(value,LIST(2,2,'ifcgridaxis', scope = schema_scope)): + self._intersectingaxes = LIST(value) + else: + self._intersectingaxes = value + return property(**locals()) + + @apply + def offsetdistances(): + def fget( self ): + return self._offsetdistances + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument offsetdistances is mantatory and can not be set to None') + if not check_type(value,LIST(2,3,'REAL', scope = schema_scope)): + self._offsetdistances = LIST(value) + else: + self._offsetdistances = value + return property(**locals()) + +#################### + # ENTITY ifclightsourceambient # +#################### +class ifclightsourceambient(ifclightsource): + '''Entity ifclightsourceambient definition. + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ): + ifclightsource.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ) + +#################### + # ENTITY ifcrelreferencedinspatialstructure # +#################### +class ifcrelreferencedinspatialstructure(ifcrelconnects): + '''Entity ifcrelreferencedinspatialstructure definition. + + :param relatedelements + :type relatedelements:SET(1,None,'ifcproduct', scope = schema_scope) + + :param relatingstructure + :type relatingstructure:ifcspatialstructureelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedelements,relatingstructure, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedelements = relatedelements + self.relatingstructure = relatingstructure + + @apply + def relatedelements(): + def fget( self ): + return self._relatedelements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedelements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproduct', scope = schema_scope)): + self._relatedelements = SET(value) + else: + self._relatedelements = value + return property(**locals()) + + @apply + def relatingstructure(): + def fget( self ): + return self._relatingstructure + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingstructure is mantatory and can not be set to None') + if not check_type(value,ifcspatialstructureelement): + self._relatingstructure = ifcspatialstructureelement(value) + else: + self._relatingstructure = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (SIZEOF(None) == 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifccostvalue # +#################### +class ifccostvalue(ifcappliedvalue): + '''Entity ifccostvalue definition. + + :param costtype + :type costtype:ifclabel + + :param condition + :type condition:ifctext + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__appliedvalue , inherited3__unitbasis , inherited4__applicabledate , inherited5__fixeduntildate , costtype,condition, ): + ifcappliedvalue.__init__(self , inherited0__name , inherited1__description , inherited2__appliedvalue , inherited3__unitbasis , inherited4__applicabledate , inherited5__fixeduntildate , ) + self.costtype = costtype + self.condition = condition + + @apply + def costtype(): + def fget( self ): + return self._costtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument costtype is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._costtype = ifclabel(value) + else: + self._costtype = value + return property(**locals()) + + @apply + def condition(): + def fget( self ): + return self._condition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._condition = ifctext(value) + else: + self._condition = value + else: + self._condition = value + return property(**locals()) + +#################### + # ENTITY ifcflowmovingdevice # +#################### +class ifcflowmovingdevice(ifcdistributionflowelement): + '''Entity ifcflowmovingdevice definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifctwodirectionrepeatfactor # +#################### +class ifctwodirectionrepeatfactor(ifconedirectionrepeatfactor): + '''Entity ifctwodirectionrepeatfactor definition. + + :param secondrepeatfactor + :type secondrepeatfactor:ifcvector + ''' + def __init__( self , inherited0__repeatfactor , secondrepeatfactor, ): + ifconedirectionrepeatfactor.__init__(self , inherited0__repeatfactor , ) + self.secondrepeatfactor = secondrepeatfactor + + @apply + def secondrepeatfactor(): + def fget( self ): + return self._secondrepeatfactor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument secondrepeatfactor is mantatory and can not be set to None') + if not check_type(value,ifcvector): + self._secondrepeatfactor = ifcvector(value) + else: + self._secondrepeatfactor = value + return property(**locals()) + +#################### + # ENTITY ifcimagetexture # +#################### +class ifcimagetexture(ifcsurfacetexture): + '''Entity ifcimagetexture definition. + + :param urlreference + :type urlreference:ifcidentifier + ''' + def __init__( self , inherited0__repeats , inherited1__repeatt , inherited2__texturetype , inherited3__texturetransform , urlreference, ): + ifcsurfacetexture.__init__(self , inherited0__repeats , inherited1__repeatt , inherited2__texturetype , inherited3__texturetransform , ) + self.urlreference = urlreference + + @apply + def urlreference(): + def fget( self ): + return self._urlreference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument urlreference is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._urlreference = ifcidentifier(value) + else: + self._urlreference = value + return property(**locals()) + +#################### + # ENTITY ifcloop # +#################### +class ifcloop(ifctopologicalrepresentationitem): + '''Entity ifcloop definition. + ''' + def __init__( self , ): + ifctopologicalrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifcvertexloop # +#################### +class ifcvertexloop(ifcloop): + '''Entity ifcvertexloop definition. + + :param loopvertex + :type loopvertex:ifcvertex + ''' + def __init__( self , loopvertex, ): + ifcloop.__init__(self , ) + self.loopvertex = loopvertex + + @apply + def loopvertex(): + def fget( self ): + return self._loopvertex + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument loopvertex is mantatory and can not be set to None') + if not check_type(value,ifcvertex): + self._loopvertex = ifcvertex(value) + else: + self._loopvertex = value + return property(**locals()) + +#################### + # ENTITY ifcarbitraryclosedprofiledef # +#################### +class ifcarbitraryclosedprofiledef(ifcprofiledef): + '''Entity ifcarbitraryclosedprofiledef definition. + + :param outercurve + :type outercurve:ifccurve + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , outercurve, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.outercurve = outercurve + + @apply + def outercurve(): + def fget( self ): + return self._outercurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument outercurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._outercurve = ifccurve(value) + else: + self._outercurve = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.outercurve.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ( not ('IFC2X3.IFCLINE' == TYPEOF(self.outercurve))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ( not ('IFC2X3.IFCOFFSETCURVE2D' == TYPEOF(self.outercurve))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcarbitraryprofiledefwithvoids # +#################### +class ifcarbitraryprofiledefwithvoids(ifcarbitraryclosedprofiledef): + '''Entity ifcarbitraryprofiledefwithvoids definition. + + :param innercurves + :type innercurves:SET(1,None,'ifccurve', scope = schema_scope) + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__outercurve , innercurves, ): + ifcarbitraryclosedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__outercurve , ) + self.innercurves = innercurves + + @apply + def innercurves(): + def fget( self ): + return self._innercurves + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument innercurves is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifccurve', scope = schema_scope)): + self._innercurves = SET(value) + else: + self._innercurves = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.ifcprofiledef.self.profiletype == area) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcsanitaryterminaltype # +#################### +class ifcsanitaryterminaltype(ifcflowterminaltype): + '''Entity ifcsanitaryterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcsanitaryterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcsanitaryterminaltypeenum): + self._predefinedtype = ifcsanitaryterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcswitchingdevicetype # +#################### +class ifcswitchingdevicetype(ifcflowcontrollertype): + '''Entity ifcswitchingdevicetype definition. + + :param predefinedtype + :type predefinedtype:ifcswitchingdevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcswitchingdevicetypeenum): + self._predefinedtype = ifcswitchingdevicetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcapproval # +#################### +class ifcapproval(BaseEntityClass): + '''Entity ifcapproval definition. + + :param description + :type description:ifctext + + :param approvaldatetime + :type approvaldatetime:ifcdatetimeselect + + :param approvalstatus + :type approvalstatus:ifclabel + + :param approvallevel + :type approvallevel:ifclabel + + :param approvalqualifier + :type approvalqualifier:ifctext + + :param name + :type name:ifclabel + + :param identifier + :type identifier:ifcidentifier + + :param actors + :type actors:SET(0,None,'ifcapprovalactorrelationship', scope = schema_scope) + + :param isrelatedwith + :type isrelatedwith:SET(0,None,'ifcapprovalrelationship', scope = schema_scope) + + :param relates + :type relates:SET(0,None,'ifcapprovalrelationship', scope = schema_scope) + ''' + def __init__( self , description,approvaldatetime,approvalstatus,approvallevel,approvalqualifier,name,identifier, ): + self.description = description + self.approvaldatetime = approvaldatetime + self.approvalstatus = approvalstatus + self.approvallevel = approvallevel + self.approvalqualifier = approvalqualifier + self.name = name + self.identifier = identifier + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def approvaldatetime(): + def fget( self ): + return self._approvaldatetime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument approvaldatetime is mantatory and can not be set to None') + if not check_type(value,ifcdatetimeselect): + self._approvaldatetime = ifcdatetimeselect(value) + else: + self._approvaldatetime = value + return property(**locals()) + + @apply + def approvalstatus(): + def fget( self ): + return self._approvalstatus + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._approvalstatus = ifclabel(value) + else: + self._approvalstatus = value + else: + self._approvalstatus = value + return property(**locals()) + + @apply + def approvallevel(): + def fget( self ): + return self._approvallevel + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._approvallevel = ifclabel(value) + else: + self._approvallevel = value + else: + self._approvallevel = value + return property(**locals()) + + @apply + def approvalqualifier(): + def fget( self ): + return self._approvalqualifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._approvalqualifier = ifctext(value) + else: + self._approvalqualifier = value + else: + self._approvalqualifier = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def identifier(): + def fget( self ): + return self._identifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument identifier is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._identifier = ifcidentifier(value) + else: + self._identifier = value + return property(**locals()) + + @apply + def actors(): + def fget( self ): + return self._actors + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument actors is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isrelatedwith(): + def fget( self ): + return self._isrelatedwith + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isrelatedwith is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def relates(): + def fget( self ): + return self._relates + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument relates is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifccostschedule # +#################### +class ifccostschedule(ifccontrol): + '''Entity ifccostschedule definition. + + :param submittedby + :type submittedby:ifcactorselect + + :param preparedby + :type preparedby:ifcactorselect + + :param submittedon + :type submittedon:ifcdatetimeselect + + :param status + :type status:ifclabel + + :param targetusers + :type targetusers:SET(1,None,'ifcactorselect', scope = schema_scope) + + :param updatedate + :type updatedate:ifcdatetimeselect + + :param id + :type id:ifcidentifier + + :param predefinedtype + :type predefinedtype:ifccostscheduletypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , submittedby,preparedby,submittedon,status,targetusers,updatedate,id,predefinedtype, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.submittedby = submittedby + self.preparedby = preparedby + self.submittedon = submittedon + self.status = status + self.targetusers = targetusers + self.updatedate = updatedate + self.id = id + self.predefinedtype = predefinedtype + + @apply + def submittedby(): + def fget( self ): + return self._submittedby + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._submittedby = ifcactorselect(value) + else: + self._submittedby = value + else: + self._submittedby = value + return property(**locals()) + + @apply + def preparedby(): + def fget( self ): + return self._preparedby + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._preparedby = ifcactorselect(value) + else: + self._preparedby = value + else: + self._preparedby = value + return property(**locals()) + + @apply + def submittedon(): + def fget( self ): + return self._submittedon + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._submittedon = ifcdatetimeselect(value) + else: + self._submittedon = value + else: + self._submittedon = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._status = ifclabel(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def targetusers(): + def fget( self ): + return self._targetusers + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcactorselect', scope = schema_scope)): + self._targetusers = SET(value) + else: + self._targetusers = value + else: + self._targetusers = value + return property(**locals()) + + @apply + def updatedate(): + def fget( self ): + return self._updatedate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._updatedate = ifcdatetimeselect(value) + else: + self._updatedate = value + else: + self._updatedate = value + return property(**locals()) + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._id = ifcidentifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccostscheduletypeenum): + self._predefinedtype = ifccostscheduletypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifclibraryreference # +#################### +class ifclibraryreference(ifcexternalreference): + '''Entity ifclibraryreference definition. + + :param referenceintolibrary + :type referenceintolibrary:SET(0,1,'ifclibraryinformation', scope = schema_scope) + ''' + def __init__( self , inherited0__location , inherited1__itemreference , inherited2__name , ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__itemreference , inherited2__name , ) + + @apply + def referenceintolibrary(): + def fget( self ): + return self._referenceintolibrary + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referenceintolibrary is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcmateriallist # +#################### +class ifcmateriallist(BaseEntityClass): + '''Entity ifcmateriallist definition. + + :param materials + :type materials:LIST(1,None,'ifcmaterial', scope = schema_scope) + ''' + def __init__( self , materials, ): + self.materials = materials + + @apply + def materials(): + def fget( self ): + return self._materials + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument materials is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcmaterial', scope = schema_scope)): + self._materials = LIST(value) + else: + self._materials = value + return property(**locals()) + +#################### + # ENTITY ifcplatetype # +#################### +class ifcplatetype(ifcbuildingelementtype): + '''Entity ifcplatetype definition. + + :param predefinedtype + :type predefinedtype:ifcplatetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcplatetypeenum): + self._predefinedtype = ifcplatetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcreldefinesbytype # +#################### +class ifcreldefinesbytype(ifcreldefines): + '''Entity ifcreldefinesbytype definition. + + :param relatingtype + :type relatingtype:ifctypeobject + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingtype, ): + ifcreldefines.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingtype = relatingtype + + @apply + def relatingtype(): + def fget( self ): + return self._relatingtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingtype is mantatory and can not be set to None') + if not check_type(value,ifctypeobject): + self._relatingtype = ifctypeobject(value) + else: + self._relatingtype = value + return property(**locals()) + +#################### + # ENTITY ifctable # +#################### +class ifctable(BaseEntityClass): + '''Entity ifctable definition. + + :param name + :type name:STRING + + :param rows + :type rows:LIST(1,None,'ifctablerow', scope = schema_scope) + + :param numberofcellsinrow + :type numberofcellsinrow:INTEGER + + :param numberofheadings + :type numberofheadings:INTEGER + + :param numberofdatarows + :type numberofdatarows:INTEGER + ''' + def __init__( self , name,rows, ): + self.name = name + self.rows = rows + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,STRING): + self._name = STRING(value) + else: + self._name = value + return property(**locals()) + + @apply + def rows(): + def fget( self ): + return self._rows + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rows is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifctablerow', scope = schema_scope)): + self._rows = LIST(value) + else: + self._rows = value + return property(**locals()) + + @apply + def numberofcellsinrow(): + def fget( self ): + attribute_eval = HIINDEX(self.rows[1].self.rowcells) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument numberofcellsinrow is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def numberofheadings(): + def fget( self ): + attribute_eval = SIZEOF(None) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument numberofheadings is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def numberofdatarows(): + def fget( self ): + attribute_eval = SIZEOF(None) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument numberofdatarows is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((0 <= self.numberofheadings) and (self.numberofheadings <= 1)) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcrailingtype # +#################### +class ifcrailingtype(ifcbuildingelementtype): + '''Entity ifcrailingtype definition. + + :param predefinedtype + :type predefinedtype:ifcrailingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcrailingtypeenum): + self._predefinedtype = ifcrailingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcfurnituretype # +#################### +class ifcfurnituretype(ifcfurnishingelementtype): + '''Entity ifcfurnituretype definition. + + :param assemblyplace + :type assemblyplace:ifcassemblyplaceenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , assemblyplace, ): + ifcfurnishingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.assemblyplace = assemblyplace + + @apply + def assemblyplace(): + def fget( self ): + return self._assemblyplace + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assemblyplace is mantatory and can not be set to None') + if not check_type(value,ifcassemblyplaceenum): + self._assemblyplace = ifcassemblyplaceenum(value) + else: + self._assemblyplace = value + return property(**locals()) + +#################### + # ENTITY ifcdefinedsymbol # +#################### +class ifcdefinedsymbol(ifcgeometricrepresentationitem): + '''Entity ifcdefinedsymbol definition. + + :param definition + :type definition:ifcdefinedsymbolselect + + :param target + :type target:ifccartesiantransformationoperator2d + ''' + def __init__( self , definition,target, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.definition = definition + self.target = target + + @apply + def definition(): + def fget( self ): + return self._definition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definition is mantatory and can not be set to None') + if not check_type(value,ifcdefinedsymbolselect): + self._definition = ifcdefinedsymbolselect(value) + else: + self._definition = value + return property(**locals()) + + @apply + def target(): + def fget( self ): + return self._target + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument target is mantatory and can not be set to None') + if not check_type(value,ifccartesiantransformationoperator2d): + self._target = ifccartesiantransformationoperator2d(value) + else: + self._target = value + return property(**locals()) + +#################### + # ENTITY ifcfiresuppressionterminaltype # +#################### +class ifcfiresuppressionterminaltype(ifcflowterminaltype): + '''Entity ifcfiresuppressionterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcfiresuppressionterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcfiresuppressionterminaltypeenum): + self._predefinedtype = ifcfiresuppressionterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifctendonanchor # +#################### +class ifctendonanchor(ifcreinforcingelement): + '''Entity ifctendonanchor definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , ): + ifcreinforcingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , ) + +#################### + # ENTITY ifcconstructionequipmentresource # +#################### +class ifcconstructionequipmentresource(ifcconstructionresource): + '''Entity ifcconstructionequipmentresource definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , ) + +#################### + # ENTITY ifctexturevertex # +#################### +class ifctexturevertex(BaseEntityClass): + '''Entity ifctexturevertex definition. + + :param coordinates + :type coordinates:LIST(2,2,'REAL', scope = schema_scope) + ''' + def __init__( self , coordinates, ): + self.coordinates = coordinates + + @apply + def coordinates(): + def fget( self ): + return self._coordinates + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordinates is mantatory and can not be set to None') + if not check_type(value,LIST(2,2,'REAL', scope = schema_scope)): + self._coordinates = LIST(value) + else: + self._coordinates = value + return property(**locals()) + +#################### + # ENTITY ifcpile # +#################### +class ifcpile(ifcbuildingelement): + '''Entity ifcpile definition. + + :param predefinedtype + :type predefinedtype:ifcpiletypeenum + + :param constructiontype + :type constructiontype:ifcpileconstructionenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype,constructiontype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + self.constructiontype = constructiontype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcpiletypeenum): + self._predefinedtype = ifcpiletypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def constructiontype(): + def fget( self ): + return self._constructiontype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpileconstructionenum): + self._constructiontype = ifcpileconstructionenum(value) + else: + self._constructiontype = value + else: + self._constructiontype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcpiletypeenum.self.userdefined) or ((self.predefinedtype == ifcpiletypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelassociatesappliedvalue # +#################### +class ifcrelassociatesappliedvalue(ifcrelassociates): + '''Entity ifcrelassociatesappliedvalue definition. + + :param relatingappliedvalue + :type relatingappliedvalue:ifcappliedvalue + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingappliedvalue, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingappliedvalue = relatingappliedvalue + + @apply + def relatingappliedvalue(): + def fget( self ): + return self._relatingappliedvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingappliedvalue is mantatory and can not be set to None') + if not check_type(value,ifcappliedvalue): + self._relatingappliedvalue = ifcappliedvalue(value) + else: + self._relatingappliedvalue = value + return property(**locals()) + +#################### + # ENTITY ifcrelassociateslibrary # +#################### +class ifcrelassociateslibrary(ifcrelassociates): + '''Entity ifcrelassociateslibrary definition. + + :param relatinglibrary + :type relatinglibrary:ifclibraryselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatinglibrary, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatinglibrary = relatinglibrary + + @apply + def relatinglibrary(): + def fget( self ): + return self._relatinglibrary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatinglibrary is mantatory and can not be set to None') + if not check_type(value,ifclibraryselect): + self._relatinglibrary = ifclibraryselect(value) + else: + self._relatinglibrary = value + return property(**locals()) + +#################### + # ENTITY ifcdimensioncalloutrelationship # +#################### +class ifcdimensioncalloutrelationship(ifcdraughtingcalloutrelationship): + '''Entity ifcdimensioncalloutrelationship definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relatingdraughtingcallout , inherited3__relateddraughtingcallout , ): + ifcdraughtingcalloutrelationship.__init__(self , inherited0__name , inherited1__description , inherited2__relatingdraughtingcallout , inherited3__relateddraughtingcallout , ) + def wr11(self): + eval_wr11_wr = (self.self.ifcdraughtingcalloutrelationship.self.name == ['primary','secondary']) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(TYPEOF(self.self.ifcdraughtingcalloutrelationship.self.relatingdraughtingcallout) * ['IFC2X3.IFCANGULARDIMENSION','IFC2X3.IFCDIAMETERDIMENSION','IFC2X3.IFCLINEARDIMENSION','IFC2X3.IFCRADIUSDIMENSION']) == 1) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = ( not ('IFC2X3.IFCDIMENSIONCURVEDIRECTEDCALLOUT' == TYPEOF(self.self.ifcdraughtingcalloutrelationship.self.relateddraughtingcallout))) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + +#################### + # ENTITY ifcrectanglehollowprofiledef # +#################### +class ifcrectanglehollowprofiledef(ifcrectangleprofiledef): + '''Entity ifcrectanglehollowprofiledef definition. + + :param wallthickness + :type wallthickness:ifcpositivelengthmeasure + + :param innerfilletradius + :type innerfilletradius:ifcpositivelengthmeasure + + :param outerfilletradius + :type outerfilletradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__xdim , inherited4__ydim , wallthickness,innerfilletradius,outerfilletradius, ): + ifcrectangleprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__xdim , inherited4__ydim , ) + self.wallthickness = wallthickness + self.innerfilletradius = innerfilletradius + self.outerfilletradius = outerfilletradius + + @apply + def wallthickness(): + def fget( self ): + return self._wallthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument wallthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._wallthickness = ifcpositivelengthmeasure(value) + else: + self._wallthickness = value + return property(**locals()) + + @apply + def innerfilletradius(): + def fget( self ): + return self._innerfilletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._innerfilletradius = ifcpositivelengthmeasure(value) + else: + self._innerfilletradius = value + else: + self._innerfilletradius = value + return property(**locals()) + + @apply + def outerfilletradius(): + def fget( self ): + return self._outerfilletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._outerfilletradius = ifcpositivelengthmeasure(value) + else: + self._outerfilletradius = value + else: + self._outerfilletradius = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = ((self.wallthickness < (self.self.ifcrectangleprofiledef.self.xdim / 2)) and (self.wallthickness < (self.self.ifcrectangleprofiledef.self.ydim / 2))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = (( not EXISTS(self.outerfilletradius)) or ((self.outerfilletradius <= (self.self.ifcrectangleprofiledef.self.xdim / 2)) and (self.outerfilletradius <= (self.self.ifcrectangleprofiledef.self.ydim / 2)))) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + def wr33(self): + eval_wr33_wr = (( not EXISTS(self.innerfilletradius)) or ((self.innerfilletradius <= ((self.self.ifcrectangleprofiledef.self.xdim / 2) - self.wallthickness)) and (self.innerfilletradius <= ((self.self.ifcrectangleprofiledef.self.ydim / 2) - self.wallthickness)))) + if not eval_wr33_wr: + raise AssertionError('Rule wr33 violated') + else: + return eval_wr33_wr + + +#################### + # ENTITY ifcproxy # +#################### +class ifcproxy(ifcproduct): + '''Entity ifcproxy definition. + + :param proxytype + :type proxytype:ifcobjecttypeenum + + :param tag + :type tag:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , proxytype,tag, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.proxytype = proxytype + self.tag = tag + + @apply + def proxytype(): + def fget( self ): + return self._proxytype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument proxytype is mantatory and can not be set to None') + if not check_type(value,ifcobjecttypeenum): + self._proxytype = ifcobjecttypeenum(value) + else: + self._proxytype = value + return property(**locals()) + + @apply + def tag(): + def fget( self ): + return self._tag + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._tag = ifclabel(value) + else: + self._tag = value + else: + self._tag = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcpropertyboundedvalue # +#################### +class ifcpropertyboundedvalue(ifcsimpleproperty): + '''Entity ifcpropertyboundedvalue definition. + + :param upperboundvalue + :type upperboundvalue:ifcvalue + + :param lowerboundvalue + :type lowerboundvalue:ifcvalue + + :param unit + :type unit:ifcunit + ''' + def __init__( self , inherited0__name , inherited1__description , upperboundvalue,lowerboundvalue,unit, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.upperboundvalue = upperboundvalue + self.lowerboundvalue = lowerboundvalue + self.unit = unit + + @apply + def upperboundvalue(): + def fget( self ): + return self._upperboundvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvalue): + self._upperboundvalue = ifcvalue(value) + else: + self._upperboundvalue = value + else: + self._upperboundvalue = value + return property(**locals()) + + @apply + def lowerboundvalue(): + def fget( self ): + return self._lowerboundvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvalue): + self._lowerboundvalue = ifcvalue(value) + else: + self._lowerboundvalue = value + else: + self._lowerboundvalue = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ((( not EXISTS(self.upperboundvalue)) or ( not EXISTS(self.lowerboundvalue))) or (TYPEOF(self.upperboundvalue) == TYPEOF(self.lowerboundvalue))) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (EXISTS(self.upperboundvalue) or EXISTS(self.lowerboundvalue)) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcpresentationstyleassignment # +#################### +class ifcpresentationstyleassignment(BaseEntityClass): + '''Entity ifcpresentationstyleassignment definition. + + :param styles + :type styles:SET(1,None,'ifcpresentationstyleselect', scope = schema_scope) + ''' + def __init__( self , styles, ): + self.styles = styles + + @apply + def styles(): + def fget( self ): + return self._styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcpresentationstyleselect', scope = schema_scope)): + self._styles = SET(value) + else: + self._styles = value + return property(**locals()) + +#################### + # ENTITY ifcspaceprogram # +#################### +class ifcspaceprogram(ifccontrol): + '''Entity ifcspaceprogram definition. + + :param spaceprogramidentifier + :type spaceprogramidentifier:ifcidentifier + + :param maxrequiredarea + :type maxrequiredarea:ifcareameasure + + :param minrequiredarea + :type minrequiredarea:ifcareameasure + + :param requestedlocation + :type requestedlocation:ifcspatialstructureelement + + :param standardrequiredarea + :type standardrequiredarea:ifcareameasure + + :param hasinteractionreqsfrom + :type hasinteractionreqsfrom:SET(0,None,'ifcrelinteractionrequirements', scope = schema_scope) + + :param hasinteractionreqsto + :type hasinteractionreqsto:SET(0,None,'ifcrelinteractionrequirements', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , spaceprogramidentifier,maxrequiredarea,minrequiredarea,requestedlocation,standardrequiredarea, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.spaceprogramidentifier = spaceprogramidentifier + self.maxrequiredarea = maxrequiredarea + self.minrequiredarea = minrequiredarea + self.requestedlocation = requestedlocation + self.standardrequiredarea = standardrequiredarea + + @apply + def spaceprogramidentifier(): + def fget( self ): + return self._spaceprogramidentifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument spaceprogramidentifier is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._spaceprogramidentifier = ifcidentifier(value) + else: + self._spaceprogramidentifier = value + return property(**locals()) + + @apply + def maxrequiredarea(): + def fget( self ): + return self._maxrequiredarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._maxrequiredarea = ifcareameasure(value) + else: + self._maxrequiredarea = value + else: + self._maxrequiredarea = value + return property(**locals()) + + @apply + def minrequiredarea(): + def fget( self ): + return self._minrequiredarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._minrequiredarea = ifcareameasure(value) + else: + self._minrequiredarea = value + else: + self._minrequiredarea = value + return property(**locals()) + + @apply + def requestedlocation(): + def fget( self ): + return self._requestedlocation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcspatialstructureelement): + self._requestedlocation = ifcspatialstructureelement(value) + else: + self._requestedlocation = value + else: + self._requestedlocation = value + return property(**locals()) + + @apply + def standardrequiredarea(): + def fget( self ): + return self._standardrequiredarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument standardrequiredarea is mantatory and can not be set to None') + if not check_type(value,ifcareameasure): + self._standardrequiredarea = ifcareameasure(value) + else: + self._standardrequiredarea = value + return property(**locals()) + + @apply + def hasinteractionreqsfrom(): + def fget( self ): + return self._hasinteractionreqsfrom + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasinteractionreqsfrom is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasinteractionreqsto(): + def fget( self ): + return self._hasinteractionreqsto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasinteractionreqsto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsite # +#################### +class ifcsite(ifcspatialstructureelement): + '''Entity ifcsite definition. + + :param reflatitude + :type reflatitude:LIST(3,4,'INTEGER', scope = schema_scope) + + :param reflongitude + :type reflongitude:LIST(3,4,'INTEGER', scope = schema_scope) + + :param refelevation + :type refelevation:ifclengthmeasure + + :param landtitlenumber + :type landtitlenumber:ifclabel + + :param siteaddress + :type siteaddress:ifcpostaladdress + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , reflatitude,reflongitude,refelevation,landtitlenumber,siteaddress, ): + ifcspatialstructureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , ) + self.reflatitude = reflatitude + self.reflongitude = reflongitude + self.refelevation = refelevation + self.landtitlenumber = landtitlenumber + self.siteaddress = siteaddress + + @apply + def reflatitude(): + def fget( self ): + return self._reflatitude + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(3,4,'INTEGER', scope = schema_scope)): + self._reflatitude = LIST(value) + else: + self._reflatitude = value + else: + self._reflatitude = value + return property(**locals()) + + @apply + def reflongitude(): + def fget( self ): + return self._reflongitude + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(3,4,'INTEGER', scope = schema_scope)): + self._reflongitude = LIST(value) + else: + self._reflongitude = value + else: + self._reflongitude = value + return property(**locals()) + + @apply + def refelevation(): + def fget( self ): + return self._refelevation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._refelevation = ifclengthmeasure(value) + else: + self._refelevation = value + else: + self._refelevation = value + return property(**locals()) + + @apply + def landtitlenumber(): + def fget( self ): + return self._landtitlenumber + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._landtitlenumber = ifclabel(value) + else: + self._landtitlenumber = value + else: + self._landtitlenumber = value + return property(**locals()) + + @apply + def siteaddress(): + def fget( self ): + return self._siteaddress + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpostaladdress): + self._siteaddress = ifcpostaladdress(value) + else: + self._siteaddress = value + else: + self._siteaddress = value + return property(**locals()) + +#################### + # ENTITY ifcarbitraryopenprofiledef # +#################### +class ifcarbitraryopenprofiledef(ifcprofiledef): + '''Entity ifcarbitraryopenprofiledef definition. + + :param curve + :type curve:ifcboundedcurve + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , curve, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.curve = curve + + @apply + def curve(): + def fget( self ): + return self._curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curve is mantatory and can not be set to None') + if not check_type(value,ifcboundedcurve): + self._curve = ifcboundedcurve(value) + else: + self._curve = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (('IFC2X3.IFCCENTERLINEPROFILEDEF' == TYPEOF(self)) or (self.self.ifcprofiledef.self.profiletype == ifcprofiletypeenum.self.curve)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (self.curve.self.dim == 2) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + +#################### + # ENTITY ifcquantitylength # +#################### +class ifcquantitylength(ifcphysicalsimplequantity): + '''Entity ifcquantitylength definition. + + :param lengthvalue + :type lengthvalue:ifclengthmeasure + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , lengthvalue, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.lengthvalue = lengthvalue + + @apply + def lengthvalue(): + def fget( self ): + return self._lengthvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lengthvalue is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._lengthvalue = ifclengthmeasure(value) + else: + self._lengthvalue = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.lengthunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.lengthvalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcsubcontractresource # +#################### +class ifcsubcontractresource(ifcconstructionresource): + '''Entity ifcsubcontractresource definition. + + :param subcontractor + :type subcontractor:ifcactorselect + + :param jobdescription + :type jobdescription:ifctext + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , subcontractor,jobdescription, ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , ) + self.subcontractor = subcontractor + self.jobdescription = jobdescription + + @apply + def subcontractor(): + def fget( self ): + return self._subcontractor + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._subcontractor = ifcactorselect(value) + else: + self._subcontractor = value + else: + self._subcontractor = value + return property(**locals()) + + @apply + def jobdescription(): + def fget( self ): + return self._jobdescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._jobdescription = ifctext(value) + else: + self._jobdescription = value + else: + self._jobdescription = value + return property(**locals()) + +#################### + # ENTITY ifcdoor # +#################### +class ifcdoor(ifcbuildingelement): + '''Entity ifcdoor definition. + + :param overallheight + :type overallheight:ifcpositivelengthmeasure + + :param overallwidth + :type overallwidth:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , overallheight,overallwidth, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.overallheight = overallheight + self.overallwidth = overallwidth + + @apply + def overallheight(): + def fget( self ): + return self._overallheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._overallheight = ifcpositivelengthmeasure(value) + else: + self._overallheight = value + else: + self._overallheight = value + return property(**locals()) + + @apply + def overallwidth(): + def fget( self ): + return self._overallwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._overallwidth = ifcpositivelengthmeasure(value) + else: + self._overallwidth = value + else: + self._overallwidth = value + return property(**locals()) + +#################### + # ENTITY ifctimeseries # +#################### +class ifctimeseries(BaseEntityClass): + '''Entity ifctimeseries definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param starttime + :type starttime:ifcdatetimeselect + + :param endtime + :type endtime:ifcdatetimeselect + + :param timeseriesdatatype + :type timeseriesdatatype:ifctimeseriesdatatypeenum + + :param dataorigin + :type dataorigin:ifcdataoriginenum + + :param userdefineddataorigin + :type userdefineddataorigin:ifclabel + + :param unit + :type unit:ifcunit + + :param documentedby + :type documentedby:SET(0,1,'ifctimeseriesreferencerelationship', scope = schema_scope) + ''' + def __init__( self , name,description,starttime,endtime,timeseriesdatatype,dataorigin,userdefineddataorigin,unit, ): + self.name = name + self.description = description + self.starttime = starttime + self.endtime = endtime + self.timeseriesdatatype = timeseriesdatatype + self.dataorigin = dataorigin + self.userdefineddataorigin = userdefineddataorigin + self.unit = unit + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def starttime(): + def fget( self ): + return self._starttime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument starttime is mantatory and can not be set to None') + if not check_type(value,ifcdatetimeselect): + self._starttime = ifcdatetimeselect(value) + else: + self._starttime = value + return property(**locals()) + + @apply + def endtime(): + def fget( self ): + return self._endtime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument endtime is mantatory and can not be set to None') + if not check_type(value,ifcdatetimeselect): + self._endtime = ifcdatetimeselect(value) + else: + self._endtime = value + return property(**locals()) + + @apply + def timeseriesdatatype(): + def fget( self ): + return self._timeseriesdatatype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timeseriesdatatype is mantatory and can not be set to None') + if not check_type(value,ifctimeseriesdatatypeenum): + self._timeseriesdatatype = ifctimeseriesdatatypeenum(value) + else: + self._timeseriesdatatype = value + return property(**locals()) + + @apply + def dataorigin(): + def fget( self ): + return self._dataorigin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dataorigin is mantatory and can not be set to None') + if not check_type(value,ifcdataoriginenum): + self._dataorigin = ifcdataoriginenum(value) + else: + self._dataorigin = value + return property(**locals()) + + @apply + def userdefineddataorigin(): + def fget( self ): + return self._userdefineddataorigin + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefineddataorigin = ifclabel(value) + else: + self._userdefineddataorigin = value + else: + self._userdefineddataorigin = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + + @apply + def documentedby(): + def fget( self ): + return self._documentedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument documentedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcregulartimeseries # +#################### +class ifcregulartimeseries(ifctimeseries): + '''Entity ifcregulartimeseries definition. + + :param timestep + :type timestep:ifctimemeasure + + :param values + :type values:LIST(1,None,'ifctimeseriesvalue', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__starttime , inherited3__endtime , inherited4__timeseriesdatatype , inherited5__dataorigin , inherited6__userdefineddataorigin , inherited7__unit , timestep,values, ): + ifctimeseries.__init__(self , inherited0__name , inherited1__description , inherited2__starttime , inherited3__endtime , inherited4__timeseriesdatatype , inherited5__dataorigin , inherited6__userdefineddataorigin , inherited7__unit , ) + self.timestep = timestep + self.values = values + + @apply + def timestep(): + def fget( self ): + return self._timestep + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timestep is mantatory and can not be set to None') + if not check_type(value,ifctimemeasure): + self._timestep = ifctimemeasure(value) + else: + self._timestep = value + return property(**locals()) + + @apply + def values(): + def fget( self ): + return self._values + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument values is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifctimeseriesvalue', scope = schema_scope)): + self._values = LIST(value) + else: + self._values = value + return property(**locals()) + +#################### + # ENTITY ifcdimensionpair # +#################### +class ifcdimensionpair(ifcdraughtingcalloutrelationship): + '''Entity ifcdimensionpair definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__relatingdraughtingcallout , inherited3__relateddraughtingcallout , ): + ifcdraughtingcalloutrelationship.__init__(self , inherited0__name , inherited1__description , inherited2__relatingdraughtingcallout , inherited3__relateddraughtingcallout , ) + def wr11(self): + eval_wr11_wr = (self.self.name == ['chained','parallel']) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(TYPEOF(self.self.relatingdraughtingcallout) * ['IFC2X3.IFCANGULARDIMENSION','IFC2X3.IFCDIAMETERDIMENSION','IFC2X3.IFCLINEARDIMENSION','IFC2X3.IFCRADIUSDIMENSION']) == 1) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = (SIZEOF(TYPEOF(self.self.relateddraughtingcallout) * ['IFC2X3.IFCANGULARDIMENSION','IFC2X3.IFCDIAMETERDIMENSION','IFC2X3.IFCLINEARDIMENSION','IFC2X3.IFCRADIUSDIMENSION']) == 1) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + +#################### + # ENTITY ifcdistributionport # +#################### +class ifcdistributionport(ifcport): + '''Entity ifcdistributionport definition. + + :param flowdirection + :type flowdirection:ifcflowdirectionenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , flowdirection, ): + ifcport.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.flowdirection = flowdirection + + @apply + def flowdirection(): + def fget( self ): + return self._flowdirection + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcflowdirectionenum): + self._flowdirection = ifcflowdirectionenum(value) + else: + self._flowdirection = value + else: + self._flowdirection = value + return property(**locals()) + +#################### + # ENTITY ifcenergyproperties # +#################### +class ifcenergyproperties(ifcpropertysetdefinition): + '''Entity ifcenergyproperties definition. + + :param energysequence + :type energysequence:ifcenergysequenceenum + + :param userdefinedenergysequence + :type userdefinedenergysequence:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , energysequence,userdefinedenergysequence, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.energysequence = energysequence + self.userdefinedenergysequence = userdefinedenergysequence + + @apply + def energysequence(): + def fget( self ): + return self._energysequence + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcenergysequenceenum): + self._energysequence = ifcenergysequenceenum(value) + else: + self._energysequence = value + else: + self._energysequence = value + return property(**locals()) + + @apply + def userdefinedenergysequence(): + def fget( self ): + return self._userdefinedenergysequence + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedenergysequence = ifclabel(value) + else: + self._userdefinedenergysequence = value + else: + self._userdefinedenergysequence = value + return property(**locals()) + +#################### + # ENTITY ifcelectricalelement # +#################### +class ifcelectricalelement(ifcelement): + '''Entity ifcelectricalelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifclightsourcepositional # +#################### +class ifclightsourcepositional(ifclightsource): + '''Entity ifclightsourcepositional definition. + + :param position + :type position:ifccartesianpoint + + :param radius + :type radius:ifcpositivelengthmeasure + + :param constantattenuation + :type constantattenuation:ifcreal + + :param distanceattenuation + :type distanceattenuation:ifcreal + + :param quadricattenuation + :type quadricattenuation:ifcreal + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , position,radius,constantattenuation,distanceattenuation,quadricattenuation, ): + ifclightsource.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ) + self.position = position + self.radius = radius + self.constantattenuation = constantattenuation + self.distanceattenuation = distanceattenuation + self.quadricattenuation = quadricattenuation + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._position = ifccartesianpoint(value) + else: + self._position = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + + @apply + def constantattenuation(): + def fget( self ): + return self._constantattenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constantattenuation is mantatory and can not be set to None') + if not check_type(value,ifcreal): + self._constantattenuation = ifcreal(value) + else: + self._constantattenuation = value + return property(**locals()) + + @apply + def distanceattenuation(): + def fget( self ): + return self._distanceattenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distanceattenuation is mantatory and can not be set to None') + if not check_type(value,ifcreal): + self._distanceattenuation = ifcreal(value) + else: + self._distanceattenuation = value + return property(**locals()) + + @apply + def quadricattenuation(): + def fget( self ): + return self._quadricattenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument quadricattenuation is mantatory and can not be set to None') + if not check_type(value,ifcreal): + self._quadricattenuation = ifcreal(value) + else: + self._quadricattenuation = value + return property(**locals()) + +#################### + # ENTITY ifclightsourcedirectional # +#################### +class ifclightsourcedirectional(ifclightsource): + '''Entity ifclightsourcedirectional definition. + + :param orientation + :type orientation:ifcdirection + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , orientation, ): + ifclightsource.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ) + self.orientation = orientation + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._orientation = ifcdirection(value) + else: + self._orientation = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralreaction # +#################### +class ifcstructuralreaction(ifcstructuralactivity): + '''Entity ifcstructuralreaction definition. + + :param causes + :type causes:SET(0,None,'ifcstructuralaction', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ): + ifcstructuralactivity.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ) + + @apply + def causes(): + def fget( self ): + return self._causes + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument causes is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructuralpointreaction # +#################### +class ifcstructuralpointreaction(ifcstructuralreaction): + '''Entity ifcstructuralpointreaction definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ): + ifcstructuralreaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ) + def wr61(self): + eval_wr61_wr = (SIZEOF(['IFC2X3.IFCSTRUCTURALLOADSINGLEFORCE','IFC2X3.IFCSTRUCTURALLOADSINGLEDISPLACEMENT'] * TYPEOF(self.self.ifcstructuralactivity.self.appliedload)) == 1) + if not eval_wr61_wr: + raise AssertionError('Rule wr61 violated') + else: + return eval_wr61_wr + + +#################### + # ENTITY ifcsoundproperties # +#################### +class ifcsoundproperties(ifcpropertysetdefinition): + '''Entity ifcsoundproperties definition. + + :param isattenuating + :type isattenuating:ifcboolean + + :param soundscale + :type soundscale:ifcsoundscaleenum + + :param soundvalues + :type soundvalues:LIST(1,8,'ifcsoundvalue', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , isattenuating,soundscale,soundvalues, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.isattenuating = isattenuating + self.soundscale = soundscale + self.soundvalues = soundvalues + + @apply + def isattenuating(): + def fget( self ): + return self._isattenuating + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument isattenuating is mantatory and can not be set to None') + if not check_type(value,ifcboolean): + self._isattenuating = ifcboolean(value) + else: + self._isattenuating = value + return property(**locals()) + + @apply + def soundscale(): + def fget( self ): + return self._soundscale + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsoundscaleenum): + self._soundscale = ifcsoundscaleenum(value) + else: + self._soundscale = value + else: + self._soundscale = value + return property(**locals()) + + @apply + def soundvalues(): + def fget( self ): + return self._soundvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument soundvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,8,'ifcsoundvalue', scope = schema_scope)): + self._soundvalues = LIST(value) + else: + self._soundvalues = value + return property(**locals()) + +#################### + # ENTITY ifcfastener # +#################### +class ifcfastener(ifcelementcomponent): + '''Entity ifcfastener definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcorientededge # +#################### +class ifcorientededge(ifcedge): + '''Entity ifcorientededge definition. + + :param edgeelement + :type edgeelement:ifcedge + + :param orientation + :type orientation:BOOLEAN + + :param ifcedge_edgestart + :type ifcedge_edgestart:ifcvertex + + :param ifcedge_edgeend + :type ifcedge_edgeend:ifcvertex + ''' + def __init__( self , inherited0__edgestart , inherited1__edgeend , edgeelement,orientation, ): + ifcedge.__init__(self , inherited0__edgestart , inherited1__edgeend , ) + self.edgeelement = edgeelement + self.orientation = orientation + + @apply + def edgeelement(): + def fget( self ): + return self._edgeelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgeelement is mantatory and can not be set to None') + if not check_type(value,ifcedge): + self._edgeelement = ifcedge(value) + else: + self._edgeelement = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def ifcedge_edgestart(): + def fget( self ): + attribute_eval = ifcbooleanchoose(self.orientation,self.edgeelement.self.edgestart,self.edgeelement.self.edgeend) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcedge_edgestart is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ifcedge_edgeend(): + def fget( self ): + attribute_eval = ifcbooleanchoose(self.orientation,self.edgeelement.self.edgeend,self.edgeelement.self.edgestart) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcedge_edgeend is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ( not ('IFC2X3.IFCORIENTEDEDGE' == TYPEOF(self.edgeelement))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelassociatesconstraint # +#################### +class ifcrelassociatesconstraint(ifcrelassociates): + '''Entity ifcrelassociatesconstraint definition. + + :param intent + :type intent:ifclabel + + :param relatingconstraint + :type relatingconstraint:ifcconstraint + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , intent,relatingconstraint, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.intent = intent + self.relatingconstraint = relatingconstraint + + @apply + def intent(): + def fget( self ): + return self._intent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument intent is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._intent = ifclabel(value) + else: + self._intent = value + return property(**locals()) + + @apply + def relatingconstraint(): + def fget( self ): + return self._relatingconstraint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingconstraint is mantatory and can not be set to None') + if not check_type(value,ifcconstraint): + self._relatingconstraint = ifcconstraint(value) + else: + self._relatingconstraint = value + return property(**locals()) + +#################### + # ENTITY ifctimeseriesvalue # +#################### +class ifctimeseriesvalue(BaseEntityClass): + '''Entity ifctimeseriesvalue definition. + + :param listvalues + :type listvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + ''' + def __init__( self , listvalues, ): + self.listvalues = listvalues + + @apply + def listvalues(): + def fget( self ): + return self._listvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument listvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._listvalues = LIST(value) + else: + self._listvalues = value + return property(**locals()) + +#################### + # ENTITY ifcbuildingelementpart # +#################### +class ifcbuildingelementpart(ifcbuildingelementcomponent): + '''Entity ifcbuildingelementpart definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcbuildingelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifctimeseriesreferencerelationship # +#################### +class ifctimeseriesreferencerelationship(BaseEntityClass): + '''Entity ifctimeseriesreferencerelationship definition. + + :param referencedtimeseries + :type referencedtimeseries:ifctimeseries + + :param timeseriesreferences + :type timeseriesreferences:SET(1,None,'ifcdocumentselect', scope = schema_scope) + ''' + def __init__( self , referencedtimeseries,timeseriesreferences, ): + self.referencedtimeseries = referencedtimeseries + self.timeseriesreferences = timeseriesreferences + + @apply + def referencedtimeseries(): + def fget( self ): + return self._referencedtimeseries + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument referencedtimeseries is mantatory and can not be set to None') + if not check_type(value,ifctimeseries): + self._referencedtimeseries = ifctimeseries(value) + else: + self._referencedtimeseries = value + return property(**locals()) + + @apply + def timeseriesreferences(): + def fget( self ): + return self._timeseriesreferences + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timeseriesreferences is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcdocumentselect', scope = schema_scope)): + self._timeseriesreferences = SET(value) + else: + self._timeseriesreferences = value + return property(**locals()) + +#################### + # ENTITY ifcbuildingelementproxy # +#################### +class ifcbuildingelementproxy(ifcbuildingelement): + '''Entity ifcbuildingelementproxy definition. + + :param compositiontype + :type compositiontype:ifcelementcompositionenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , compositiontype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.compositiontype = compositiontype + + @apply + def compositiontype(): + def fget( self ): + return self._compositiontype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelementcompositionenum): + self._compositiontype = ifcelementcompositionenum(value) + else: + self._compositiontype = value + else: + self._compositiontype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcdiscreteaccessorytype # +#################### +class ifcdiscreteaccessorytype(ifcelementcomponenttype): + '''Entity ifcdiscreteaccessorytype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementcomponenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcplate # +#################### +class ifcplate(ifcbuildingelement): + '''Entity ifcplate definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcconnectedfaceset # +#################### +class ifcconnectedfaceset(ifctopologicalrepresentationitem): + '''Entity ifcconnectedfaceset definition. + + :param cfsfaces + :type cfsfaces:SET(1,None,'ifcface', scope = schema_scope) + ''' + def __init__( self , cfsfaces, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.cfsfaces = cfsfaces + + @apply + def cfsfaces(): + def fget( self ): + return self._cfsfaces + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument cfsfaces is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcface', scope = schema_scope)): + self._cfsfaces = SET(value) + else: + self._cfsfaces = value + return property(**locals()) + +#################### + # ENTITY ifcclosedshell # +#################### +class ifcclosedshell(ifcconnectedfaceset): + '''Entity ifcclosedshell definition. + ''' + def __init__( self , inherited0__cfsfaces , ): + ifcconnectedfaceset.__init__(self , inherited0__cfsfaces , ) + +#################### + # ENTITY ifcrelassociatesprofileproperties # +#################### +class ifcrelassociatesprofileproperties(ifcrelassociates): + '''Entity ifcrelassociatesprofileproperties definition. + + :param relatingprofileproperties + :type relatingprofileproperties:ifcprofileproperties + + :param profilesectionlocation + :type profilesectionlocation:ifcshapeaspect + + :param profileorientation + :type profileorientation:ifcorientationselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingprofileproperties,profilesectionlocation,profileorientation, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingprofileproperties = relatingprofileproperties + self.profilesectionlocation = profilesectionlocation + self.profileorientation = profileorientation + + @apply + def relatingprofileproperties(): + def fget( self ): + return self._relatingprofileproperties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingprofileproperties is mantatory and can not be set to None') + if not check_type(value,ifcprofileproperties): + self._relatingprofileproperties = ifcprofileproperties(value) + else: + self._relatingprofileproperties = value + return property(**locals()) + + @apply + def profilesectionlocation(): + def fget( self ): + return self._profilesectionlocation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._profilesectionlocation = ifcshapeaspect(value) + else: + self._profilesectionlocation = value + else: + self._profilesectionlocation = value + return property(**locals()) + + @apply + def profileorientation(): + def fget( self ): + return self._profileorientation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcorientationselect): + self._profileorientation = ifcorientationselect(value) + else: + self._profileorientation = value + else: + self._profileorientation = value + return property(**locals()) + +#################### + # ENTITY ifcorganizationrelationship # +#################### +class ifcorganizationrelationship(BaseEntityClass): + '''Entity ifcorganizationrelationship definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param relatingorganization + :type relatingorganization:ifcorganization + + :param relatedorganizations + :type relatedorganizations:SET(1,None,'ifcorganization', scope = schema_scope) + ''' + def __init__( self , name,description,relatingorganization,relatedorganizations, ): + self.name = name + self.description = description + self.relatingorganization = relatingorganization + self.relatedorganizations = relatedorganizations + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relatingorganization(): + def fget( self ): + return self._relatingorganization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingorganization is mantatory and can not be set to None') + if not check_type(value,ifcorganization): + self._relatingorganization = ifcorganization(value) + else: + self._relatingorganization = value + return property(**locals()) + + @apply + def relatedorganizations(): + def fget( self ): + return self._relatedorganizations + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedorganizations is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcorganization', scope = schema_scope)): + self._relatedorganizations = SET(value) + else: + self._relatedorganizations = value + return property(**locals()) + +#################### + # ENTITY ifcsweptdisksolid # +#################### +class ifcsweptdisksolid(ifcsolidmodel): + '''Entity ifcsweptdisksolid definition. + + :param directrix + :type directrix:ifccurve + + :param radius + :type radius:ifcpositivelengthmeasure + + :param innerradius + :type innerradius:ifcpositivelengthmeasure + + :param startparam + :type startparam:ifcparametervalue + + :param endparam + :type endparam:ifcparametervalue + ''' + def __init__( self , directrix,radius,innerradius,startparam,endparam, ): + ifcsolidmodel.__init__(self , ) + self.directrix = directrix + self.radius = radius + self.innerradius = innerradius + self.startparam = startparam + self.endparam = endparam + + @apply + def directrix(): + def fget( self ): + return self._directrix + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directrix is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._directrix = ifccurve(value) + else: + self._directrix = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + + @apply + def innerradius(): + def fget( self ): + return self._innerradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._innerradius = ifcpositivelengthmeasure(value) + else: + self._innerradius = value + else: + self._innerradius = value + return property(**locals()) + + @apply + def startparam(): + def fget( self ): + return self._startparam + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument startparam is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._startparam = ifcparametervalue(value) + else: + self._startparam = value + return property(**locals()) + + @apply + def endparam(): + def fget( self ): + return self._endparam + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument endparam is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._endparam = ifcparametervalue(value) + else: + self._endparam = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.directrix.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not EXISTS(self.innerradius)) or (self.radius > self.innerradius)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifccovering # +#################### +class ifccovering(ifcbuildingelement): + '''Entity ifccovering definition. + + :param predefinedtype + :type predefinedtype:ifccoveringtypeenum + + :param coversspaces + :type coversspaces:SET(0,1,'ifcrelcoversspaces', scope = schema_scope) + + :param covers + :type covers:SET(0,1,'ifcrelcoversbldgelements', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccoveringtypeenum): + self._predefinedtype = ifccoveringtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def coversspaces(): + def fget( self ): + return self._coversspaces + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument coversspaces is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def covers(): + def fget( self ): + return self._covers + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument covers is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr61(self): + eval_wr61_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccoveringtypeenum.self.userdefined)) or ((self.predefinedtype == ifccoveringtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_wr61_wr: + raise AssertionError('Rule wr61 violated') + else: + return eval_wr61_wr + + +#################### + # ENTITY ifcquantitytime # +#################### +class ifcquantitytime(ifcphysicalsimplequantity): + '''Entity ifcquantitytime definition. + + :param timevalue + :type timevalue:ifctimemeasure + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , timevalue, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.timevalue = timevalue + + @apply + def timevalue(): + def fget( self ): + return self._timevalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timevalue is mantatory and can not be set to None') + if not check_type(value,ifctimemeasure): + self._timevalue = ifctimemeasure(value) + else: + self._timevalue = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.timeunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.timevalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcdocumentinformationrelationship # +#################### +class ifcdocumentinformationrelationship(BaseEntityClass): + '''Entity ifcdocumentinformationrelationship definition. + + :param relatingdocument + :type relatingdocument:ifcdocumentinformation + + :param relateddocuments + :type relateddocuments:SET(1,None,'ifcdocumentinformation', scope = schema_scope) + + :param relationshiptype + :type relationshiptype:ifclabel + ''' + def __init__( self , relatingdocument,relateddocuments,relationshiptype, ): + self.relatingdocument = relatingdocument + self.relateddocuments = relateddocuments + self.relationshiptype = relationshiptype + + @apply + def relatingdocument(): + def fget( self ): + return self._relatingdocument + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingdocument is mantatory and can not be set to None') + if not check_type(value,ifcdocumentinformation): + self._relatingdocument = ifcdocumentinformation(value) + else: + self._relatingdocument = value + return property(**locals()) + + @apply + def relateddocuments(): + def fget( self ): + return self._relateddocuments + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relateddocuments is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcdocumentinformation', scope = schema_scope)): + self._relateddocuments = SET(value) + else: + self._relateddocuments = value + return property(**locals()) + + @apply + def relationshiptype(): + def fget( self ): + return self._relationshiptype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._relationshiptype = ifclabel(value) + else: + self._relationshiptype = value + else: + self._relationshiptype = value + return property(**locals()) + +#################### + # ENTITY ifcgeometricrepresentationsubcontext # +#################### +class ifcgeometricrepresentationsubcontext(ifcgeometricrepresentationcontext): + '''Entity ifcgeometricrepresentationsubcontext definition. + + :param parentcontext + :type parentcontext:ifcgeometricrepresentationcontext + + :param targetscale + :type targetscale:ifcpositiveratiomeasure + + :param targetview + :type targetview:ifcgeometricprojectionenum + + :param userdefinedtargetview + :type userdefinedtargetview:ifclabel + + :param ifcgeometricrepresentationcontext_worldcoordinatesystem + :type ifcgeometricrepresentationcontext_worldcoordinatesystem:ifcaxis2placement + + :param ifcgeometricrepresentationcontext_coordinatespacedimension + :type ifcgeometricrepresentationcontext_coordinatespacedimension:ifcdimensioncount + + :param ifcgeometricrepresentationcontext_truenorth + :type ifcgeometricrepresentationcontext_truenorth:ifcdirection + + :param ifcgeometricrepresentationcontext_precision + :type ifcgeometricrepresentationcontext_precision:REAL + ''' + def __init__( self , inherited0__contextidentifier , inherited1__contexttype , inherited2__coordinatespacedimension , inherited3__precision , inherited4__worldcoordinatesystem , inherited5__truenorth , parentcontext,targetscale,targetview,userdefinedtargetview, ): + ifcgeometricrepresentationcontext.__init__(self , inherited0__contextidentifier , inherited1__contexttype , inherited2__coordinatespacedimension , inherited3__precision , inherited4__worldcoordinatesystem , inherited5__truenorth , ) + self.parentcontext = parentcontext + self.targetscale = targetscale + self.targetview = targetview + self.userdefinedtargetview = userdefinedtargetview + + @apply + def parentcontext(): + def fget( self ): + return self._parentcontext + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parentcontext is mantatory and can not be set to None') + if not check_type(value,ifcgeometricrepresentationcontext): + self._parentcontext = ifcgeometricrepresentationcontext(value) + else: + self._parentcontext = value + return property(**locals()) + + @apply + def targetscale(): + def fget( self ): + return self._targetscale + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._targetscale = ifcpositiveratiomeasure(value) + else: + self._targetscale = value + else: + self._targetscale = value + return property(**locals()) + + @apply + def targetview(): + def fget( self ): + return self._targetview + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument targetview is mantatory and can not be set to None') + if not check_type(value,ifcgeometricprojectionenum): + self._targetview = ifcgeometricprojectionenum(value) + else: + self._targetview = value + return property(**locals()) + + @apply + def userdefinedtargetview(): + def fget( self ): + return self._userdefinedtargetview + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedtargetview = ifclabel(value) + else: + self._userdefinedtargetview = value + else: + self._userdefinedtargetview = value + return property(**locals()) + + @apply + def ifcgeometricrepresentationcontext_worldcoordinatesystem(): + def fget( self ): + attribute_eval = self.parentcontext.self.worldcoordinatesystem + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcgeometricrepresentationcontext_worldcoordinatesystem is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ifcgeometricrepresentationcontext_coordinatespacedimension(): + def fget( self ): + attribute_eval = self.parentcontext.self.coordinatespacedimension + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcgeometricrepresentationcontext_coordinatespacedimension is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ifcgeometricrepresentationcontext_truenorth(): + def fget( self ): + attribute_eval = NVL(self.parentcontext.self.truenorth,self.self.worldcoordinatesystem.self.p[2]) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcgeometricrepresentationcontext_truenorth is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ifcgeometricrepresentationcontext_precision(): + def fget( self ): + attribute_eval = NVL(self.parentcontext.self.precision,1e-005) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcgeometricrepresentationcontext_precision is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr31(self): + eval_wr31_wr = ( not ('IFC2X3.IFCGEOMETRICREPRESENTATIONSUBCONTEXT' == TYPEOF(self.parentcontext))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = ((self.targetview != ifcgeometricprojectionenum.self.userdefined) or ((self.targetview == ifcgeometricprojectionenum.self.userdefined) and EXISTS(self.userdefinedtargetview))) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + +#################### + # ENTITY ifcdocumentreference # +#################### +class ifcdocumentreference(ifcexternalreference): + '''Entity ifcdocumentreference definition. + + :param referencetodocument + :type referencetodocument:SET(0,1,'ifcdocumentinformation', scope = schema_scope) + ''' + def __init__( self , inherited0__location , inherited1__itemreference , inherited2__name , ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__itemreference , inherited2__name , ) + + @apply + def referencetodocument(): + def fget( self ): + return self._referencetodocument + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referencetodocument is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (EXISTS(self.name) XOR EXISTS(self.referencetodocument[1])) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcexternallydefinedtextfont # +#################### +class ifcexternallydefinedtextfont(ifcexternalreference): + '''Entity ifcexternallydefinedtextfont definition. + ''' + def __init__( self , inherited0__location , inherited1__itemreference , inherited2__name , ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__itemreference , inherited2__name , ) + +#################### + # ENTITY ifcnamedunit # +#################### +class ifcnamedunit(BaseEntityClass): + '''Entity ifcnamedunit definition. + + :param dimensions + :type dimensions:ifcdimensionalexponents + + :param unittype + :type unittype:ifcunitenum + ''' + def __init__( self , dimensions,unittype, ): + self.dimensions = dimensions + self.unittype = unittype + + @apply + def dimensions(): + def fget( self ): + return self._dimensions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dimensions is mantatory and can not be set to None') + if not check_type(value,ifcdimensionalexponents): + self._dimensions = ifcdimensionalexponents(value) + else: + self._dimensions = value + return property(**locals()) + + @apply + def unittype(): + def fget( self ): + return self._unittype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unittype is mantatory and can not be set to None') + if not check_type(value,ifcunitenum): + self._unittype = ifcunitenum(value) + else: + self._unittype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ifccorrectdimensions(self.self.unittype,self.self.dimensions) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcconstraintaggregationrelationship # +#################### +class ifcconstraintaggregationrelationship(BaseEntityClass): + '''Entity ifcconstraintaggregationrelationship definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param relatingconstraint + :type relatingconstraint:ifcconstraint + + :param relatedconstraints + :type relatedconstraints:LIST(1,None,'ifcconstraint', scope = schema_scope) + + :param logicalaggregator + :type logicalaggregator:ifclogicaloperatorenum + ''' + def __init__( self , name,description,relatingconstraint,relatedconstraints,logicalaggregator, ): + self.name = name + self.description = description + self.relatingconstraint = relatingconstraint + self.relatedconstraints = relatedconstraints + self.logicalaggregator = logicalaggregator + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def relatingconstraint(): + def fget( self ): + return self._relatingconstraint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingconstraint is mantatory and can not be set to None') + if not check_type(value,ifcconstraint): + self._relatingconstraint = ifcconstraint(value) + else: + self._relatingconstraint = value + return property(**locals()) + + @apply + def relatedconstraints(): + def fget( self ): + return self._relatedconstraints + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedconstraints is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcconstraint', scope = schema_scope)): + self._relatedconstraints = LIST(value) + else: + self._relatedconstraints = value + return property(**locals()) + + @apply + def logicalaggregator(): + def fget( self ): + return self._logicalaggregator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument logicalaggregator is mantatory and can not be set to None') + if not check_type(value,ifclogicaloperatorenum): + self._logicalaggregator = ifclogicaloperatorenum(value) + else: + self._logicalaggregator = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcrelassignstoprojectorder # +#################### +class ifcrelassignstoprojectorder(ifcrelassignstocontrol): + '''Entity ifcrelassignstoprojectorder definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatingcontrol , ): + ifcrelassignstocontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatingcontrol , ) + +#################### + # ENTITY ifcconnectioncurvegeometry # +#################### +class ifcconnectioncurvegeometry(ifcconnectiongeometry): + '''Entity ifcconnectioncurvegeometry definition. + + :param curveonrelatingelement + :type curveonrelatingelement:ifccurveoredgecurve + + :param curveonrelatedelement + :type curveonrelatedelement:ifccurveoredgecurve + ''' + def __init__( self , curveonrelatingelement,curveonrelatedelement, ): + ifcconnectiongeometry.__init__(self , ) + self.curveonrelatingelement = curveonrelatingelement + self.curveonrelatedelement = curveonrelatedelement + + @apply + def curveonrelatingelement(): + def fget( self ): + return self._curveonrelatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curveonrelatingelement is mantatory and can not be set to None') + if not check_type(value,ifccurveoredgecurve): + self._curveonrelatingelement = ifccurveoredgecurve(value) + else: + self._curveonrelatingelement = value + return property(**locals()) + + @apply + def curveonrelatedelement(): + def fget( self ): + return self._curveonrelatedelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccurveoredgecurve): + self._curveonrelatedelement = ifccurveoredgecurve(value) + else: + self._curveonrelatedelement = value + else: + self._curveonrelatedelement = value + return property(**locals()) + +#################### + # ENTITY ifcdraughtingpredefinedcolour # +#################### +class ifcdraughtingpredefinedcolour(ifcpredefinedcolour): + '''Entity ifcdraughtingpredefinedcolour definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefinedcolour.__init__(self , inherited0__name , ) + def wr31(self): + eval_wr31_wr = (self.self.ifcpredefineditem.self.name == ['black','red','green','blue','yellow','magenta','cyan','white','by layer']) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcrelcoversspaces # +#################### +class ifcrelcoversspaces(ifcrelconnects): + '''Entity ifcrelcoversspaces definition. + + :param relatedspace + :type relatedspace:ifcspace + + :param relatedcoverings + :type relatedcoverings:SET(1,None,'ifccovering', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedspace,relatedcoverings, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedspace = relatedspace + self.relatedcoverings = relatedcoverings + + @apply + def relatedspace(): + def fget( self ): + return self._relatedspace + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedspace is mantatory and can not be set to None') + if not check_type(value,ifcspace): + self._relatedspace = ifcspace(value) + else: + self._relatedspace = value + return property(**locals()) + + @apply + def relatedcoverings(): + def fget( self ): + return self._relatedcoverings + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedcoverings is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifccovering', scope = schema_scope)): + self._relatedcoverings = SET(value) + else: + self._relatedcoverings = value + return property(**locals()) + +#################### + # ENTITY ifcstructureddimensioncallout # +#################### +class ifcstructureddimensioncallout(ifcdraughtingcallout): + '''Entity ifcstructureddimensioncallout definition. + ''' + def __init__( self , inherited0__contents , ): + ifcdraughtingcallout.__init__(self , inherited0__contents , ) + def wr31(self): + eval_wr31_wr = (SIZEOF(None) == 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifclaborresource # +#################### +class ifclaborresource(ifcconstructionresource): + '''Entity ifclaborresource definition. + + :param skillset + :type skillset:ifctext + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , skillset, ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , ) + self.skillset = skillset + + @apply + def skillset(): + def fget( self ): + return self._skillset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._skillset = ifctext(value) + else: + self._skillset = value + else: + self._skillset = value + return property(**locals()) + +#################### + # ENTITY ifcmechanicalfastenertype # +#################### +class ifcmechanicalfastenertype(ifcfastenertype): + '''Entity ifcmechanicalfastenertype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcfastenertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcquantityweight # +#################### +class ifcquantityweight(ifcphysicalsimplequantity): + '''Entity ifcquantityweight definition. + + :param weightvalue + :type weightvalue:ifcmassmeasure + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , weightvalue, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.weightvalue = weightvalue + + @apply + def weightvalue(): + def fget( self ): + return self._weightvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument weightvalue is mantatory and can not be set to None') + if not check_type(value,ifcmassmeasure): + self._weightvalue = ifcmassmeasure(value) + else: + self._weightvalue = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.massunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.weightvalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcstructuralloadgroup # +#################### +class ifcstructuralloadgroup(ifcgroup): + '''Entity ifcstructuralloadgroup definition. + + :param predefinedtype + :type predefinedtype:ifcloadgrouptypeenum + + :param actiontype + :type actiontype:ifcactiontypeenum + + :param actionsource + :type actionsource:ifcactionsourcetypeenum + + :param coefficient + :type coefficient:ifcratiomeasure + + :param purpose + :type purpose:ifclabel + + :param sourceofresultgroup + :type sourceofresultgroup:SET(0,1,'ifcstructuralresultgroup', scope = schema_scope) + + :param loadgroupfor + :type loadgroupfor:SET(0,None,'ifcstructuralanalysismodel', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , predefinedtype,actiontype,actionsource,coefficient,purpose, ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.predefinedtype = predefinedtype + self.actiontype = actiontype + self.actionsource = actionsource + self.coefficient = coefficient + self.purpose = purpose + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcloadgrouptypeenum): + self._predefinedtype = ifcloadgrouptypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def actiontype(): + def fget( self ): + return self._actiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actiontype is mantatory and can not be set to None') + if not check_type(value,ifcactiontypeenum): + self._actiontype = ifcactiontypeenum(value) + else: + self._actiontype = value + return property(**locals()) + + @apply + def actionsource(): + def fget( self ): + return self._actionsource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actionsource is mantatory and can not be set to None') + if not check_type(value,ifcactionsourcetypeenum): + self._actionsource = ifcactionsourcetypeenum(value) + else: + self._actionsource = value + return property(**locals()) + + @apply + def coefficient(): + def fget( self ): + return self._coefficient + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcratiomeasure): + self._coefficient = ifcratiomeasure(value) + else: + self._coefficient = value + else: + self._coefficient = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._purpose = ifclabel(value) + else: + self._purpose = value + else: + self._purpose = value + return property(**locals()) + + @apply + def sourceofresultgroup(): + def fget( self ): + return self._sourceofresultgroup + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument sourceofresultgroup is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def loadgroupfor(): + def fget( self ): + return self._loadgroupfor + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument loadgroupfor is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcwalltype # +#################### +class ifcwalltype(ifcbuildingelementtype): + '''Entity ifcwalltype definition. + + :param predefinedtype + :type predefinedtype:ifcwalltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcwalltypeenum): + self._predefinedtype = ifcwalltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcconstructionmaterialresource # +#################### +class ifcconstructionmaterialresource(ifcconstructionresource): + '''Entity ifcconstructionmaterialresource definition. + + :param suppliers + :type suppliers:SET(1,None,'ifcactorselect', scope = schema_scope) + + :param usageratio + :type usageratio:ifcratiomeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , suppliers,usageratio, ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , ) + self.suppliers = suppliers + self.usageratio = usageratio + + @apply + def suppliers(): + def fget( self ): + return self._suppliers + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcactorselect', scope = schema_scope)): + self._suppliers = SET(value) + else: + self._suppliers = value + else: + self._suppliers = value + return property(**locals()) + + @apply + def usageratio(): + def fget( self ): + return self._usageratio + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcratiomeasure): + self._usageratio = ifcratiomeasure(value) + else: + self._usageratio = value + else: + self._usageratio = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.ifcresource.self.resourceof) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not EXISTS(self.self.ifcresource.self.resourceof[1])) or (self.self.ifcresource.self.resourceof[1].self.relatedobjectstype == ifcobjecttypeenum.self.product)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcradiusdimension # +#################### +class ifcradiusdimension(ifcdimensioncurvedirectedcallout): + '''Entity ifcradiusdimension definition. + ''' + def __init__( self , inherited0__contents , ): + ifcdimensioncurvedirectedcallout.__init__(self , inherited0__contents , ) + +#################### + # ENTITY ifcapprovalrelationship # +#################### +class ifcapprovalrelationship(BaseEntityClass): + '''Entity ifcapprovalrelationship definition. + + :param relatedapproval + :type relatedapproval:ifcapproval + + :param relatingapproval + :type relatingapproval:ifcapproval + + :param description + :type description:ifctext + + :param name + :type name:ifclabel + ''' + def __init__( self , relatedapproval,relatingapproval,description,name, ): + self.relatedapproval = relatedapproval + self.relatingapproval = relatingapproval + self.description = description + self.name = name + + @apply + def relatedapproval(): + def fget( self ): + return self._relatedapproval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedapproval is mantatory and can not be set to None') + if not check_type(value,ifcapproval): + self._relatedapproval = ifcapproval(value) + else: + self._relatedapproval = value + return property(**locals()) + + @apply + def relatingapproval(): + def fget( self ): + return self._relatingapproval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingapproval is mantatory and can not be set to None') + if not check_type(value,ifcapproval): + self._relatingapproval = ifcapproval(value) + else: + self._relatingapproval = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcboundingbox # +#################### +class ifcboundingbox(ifcgeometricrepresentationitem): + '''Entity ifcboundingbox definition. + + :param corner + :type corner:ifccartesianpoint + + :param xdim + :type xdim:ifcpositivelengthmeasure + + :param ydim + :type ydim:ifcpositivelengthmeasure + + :param zdim + :type zdim:ifcpositivelengthmeasure + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , corner,xdim,ydim,zdim, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.corner = corner + self.xdim = xdim + self.ydim = ydim + self.zdim = zdim + + @apply + def corner(): + def fget( self ): + return self._corner + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument corner is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._corner = ifccartesianpoint(value) + else: + self._corner = value + return property(**locals()) + + @apply + def xdim(): + def fget( self ): + return self._xdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument xdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._xdim = ifcpositivelengthmeasure(value) + else: + self._xdim = value + return property(**locals()) + + @apply + def ydim(): + def fget( self ): + return self._ydim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ydim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ydim = ifcpositivelengthmeasure(value) + else: + self._ydim = value + return property(**locals()) + + @apply + def zdim(): + def fget( self ): + return self._zdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument zdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._zdim = ifcpositivelengthmeasure(value) + else: + self._zdim = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifctextstylefordefinedfont # +#################### +class ifctextstylefordefinedfont(BaseEntityClass): + '''Entity ifctextstylefordefinedfont definition. + + :param colour + :type colour:ifccolour + + :param backgroundcolour + :type backgroundcolour:ifccolour + ''' + def __init__( self , colour,backgroundcolour, ): + self.colour = colour + self.backgroundcolour = backgroundcolour + + @apply + def colour(): + def fget( self ): + return self._colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colour is mantatory and can not be set to None') + if not check_type(value,ifccolour): + self._colour = ifccolour(value) + else: + self._colour = value + return property(**locals()) + + @apply + def backgroundcolour(): + def fget( self ): + return self._backgroundcolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolour): + self._backgroundcolour = ifccolour(value) + else: + self._backgroundcolour = value + else: + self._backgroundcolour = value + return property(**locals()) + +#################### + # ENTITY ifcconstructionproductresource # +#################### +class ifcconstructionproductresource(ifcconstructionresource): + '''Entity ifcconstructionproductresource definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__resourceidentifier , inherited6__resourcegroup , inherited7__resourceconsumption , inherited8__basequantity , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.self.ifcresource.self.resourceof) <= 1) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not EXISTS(self.self.ifcresource.self.resourceof[1])) or (self.self.ifcresource.self.resourceof[1].self.relatedobjectstype == ifcobjecttypeenum.self.product)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcmonetaryunit # +#################### +class ifcmonetaryunit(BaseEntityClass): + '''Entity ifcmonetaryunit definition. + + :param currency + :type currency:ifccurrencyenum + ''' + def __init__( self , currency, ): + self.currency = currency + + @apply + def currency(): + def fget( self ): + return self._currency + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument currency is mantatory and can not be set to None') + if not check_type(value,ifccurrencyenum): + self._currency = ifccurrencyenum(value) + else: + self._currency = value + return property(**locals()) + +#################### + # ENTITY ifcpropertysinglevalue # +#################### +class ifcpropertysinglevalue(ifcsimpleproperty): + '''Entity ifcpropertysinglevalue definition. + + :param nominalvalue + :type nominalvalue:ifcvalue + + :param unit + :type unit:ifcunit + ''' + def __init__( self , inherited0__name , inherited1__description , nominalvalue,unit, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.nominalvalue = nominalvalue + self.unit = unit + + @apply + def nominalvalue(): + def fget( self ): + return self._nominalvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvalue): + self._nominalvalue = ifcvalue(value) + else: + self._nominalvalue = value + else: + self._nominalvalue = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + +#################### + # ENTITY ifcrelassignstoprocess # +#################### +class ifcrelassignstoprocess(ifcrelassigns): + '''Entity ifcrelassignstoprocess definition. + + :param relatingprocess + :type relatingprocess:ifcprocess + + :param quantityinprocess + :type quantityinprocess:ifcmeasurewithunit + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingprocess,quantityinprocess, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingprocess = relatingprocess + self.quantityinprocess = quantityinprocess + + @apply + def relatingprocess(): + def fget( self ): + return self._relatingprocess + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingprocess is mantatory and can not be set to None') + if not check_type(value,ifcprocess): + self._relatingprocess = ifcprocess(value) + else: + self._relatingprocess = value + return property(**locals()) + + @apply + def quantityinprocess(): + def fget( self ): + return self._quantityinprocess + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmeasurewithunit): + self._quantityinprocess = ifcmeasurewithunit(value) + else: + self._quantityinprocess = value + else: + self._quantityinprocess = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcsiunit # +#################### +class ifcsiunit(ifcnamedunit): + '''Entity ifcsiunit definition. + + :param prefix + :type prefix:ifcsiprefix + + :param name + :type name:ifcsiunitname + + :param ifcnamedunit_dimensions + :type ifcnamedunit_dimensions:ifcdimensionalexponents + ''' + def __init__( self , inherited0__dimensions , inherited1__unittype , prefix,name, ): + ifcnamedunit.__init__(self , inherited0__dimensions , inherited1__unittype , ) + self.prefix = prefix + self.name = name + + @apply + def prefix(): + def fget( self ): + return self._prefix + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsiprefix): + self._prefix = ifcsiprefix(value) + else: + self._prefix = value + else: + self._prefix = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifcsiunitname): + self._name = ifcsiunitname(value) + else: + self._name = value + return property(**locals()) + + @apply + def ifcnamedunit_dimensions(): + def fget( self ): + attribute_eval = ifcdimensionsforsiunit(self.self.name) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcnamedunit_dimensions is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcspaceheatertype # +#################### +class ifcspaceheatertype(ifcenergyconversiondevicetype): + '''Entity ifcspaceheatertype definition. + + :param predefinedtype + :type predefinedtype:ifcspaceheatertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcspaceheatertypeenum): + self._predefinedtype = ifcspaceheatertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcspaceheatertypeenum.self.userdefined) or ((self.predefinedtype == ifcspaceheatertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcdistributionchamberelementtype # +#################### +class ifcdistributionchamberelementtype(ifcdistributionflowelementtype): + '''Entity ifcdistributionchamberelementtype definition. + + :param predefinedtype + :type predefinedtype:ifcdistributionchamberelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcdistributionchamberelementtypeenum): + self._predefinedtype = ifcdistributionchamberelementtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralcurvemember # +#################### +class ifcstructuralcurvemember(ifcstructuralmember): + '''Entity ifcstructuralcurvemember definition. + + :param predefinedtype + :type predefinedtype:ifcstructuralcurvetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , predefinedtype, ): + ifcstructuralmember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstructuralcurvetypeenum): + self._predefinedtype = ifcstructuralcurvetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcjunctionboxtype # +#################### +class ifcjunctionboxtype(ifcflowfittingtype): + '''Entity ifcjunctionboxtype definition. + + :param predefinedtype + :type predefinedtype:ifcjunctionboxtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowfittingtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcjunctionboxtypeenum): + self._predefinedtype = ifcjunctionboxtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifccontextdependentunit # +#################### +class ifccontextdependentunit(ifcnamedunit): + '''Entity ifccontextdependentunit definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , inherited0__dimensions , inherited1__unittype , name, ): + ifcnamedunit.__init__(self , inherited0__dimensions , inherited1__unittype , ) + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcsectionproperties # +#################### +class ifcsectionproperties(BaseEntityClass): + '''Entity ifcsectionproperties definition. + + :param sectiontype + :type sectiontype:ifcsectiontypeenum + + :param startprofile + :type startprofile:ifcprofiledef + + :param endprofile + :type endprofile:ifcprofiledef + ''' + def __init__( self , sectiontype,startprofile,endprofile, ): + self.sectiontype = sectiontype + self.startprofile = startprofile + self.endprofile = endprofile + + @apply + def sectiontype(): + def fget( self ): + return self._sectiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sectiontype is mantatory and can not be set to None') + if not check_type(value,ifcsectiontypeenum): + self._sectiontype = ifcsectiontypeenum(value) + else: + self._sectiontype = value + return property(**locals()) + + @apply + def startprofile(): + def fget( self ): + return self._startprofile + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument startprofile is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._startprofile = ifcprofiledef(value) + else: + self._startprofile = value + return property(**locals()) + + @apply + def endprofile(): + def fget( self ): + return self._endprofile + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcprofiledef): + self._endprofile = ifcprofiledef(value) + else: + self._endprofile = value + else: + self._endprofile = value + return property(**locals()) + +#################### + # ENTITY ifcshaperepresentation # +#################### +class ifcshaperepresentation(ifcshapemodel): + '''Entity ifcshaperepresentation definition. + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcshapemodel.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + def wr21(self): + eval_wr21_wr = ('IFC2X3.IFCGEOMETRICREPRESENTATIONCONTEXT' == TYPEOF(self.self.ifcrepresentation.self.contextofitems)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (SIZEOF(None) == 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + def wr23(self): + eval_wr23_wr = EXISTS(self.self.ifcrepresentation.self.representationtype) + if not eval_wr23_wr: + raise AssertionError('Rule wr23 violated') + else: + return eval_wr23_wr + + def wr24(self): + eval_wr24_wr = ifcshaperepresentationtypes(self.self.ifcrepresentation.self.representationtype,self.self.ifcrepresentation.self.items) + if not eval_wr24_wr: + raise AssertionError('Rule wr24 violated') + else: + return eval_wr24_wr + + +#################### + # ENTITY ifcfiltertype # +#################### +class ifcfiltertype(ifcflowtreatmentdevicetype): + '''Entity ifcfiltertype definition. + + :param predefinedtype + :type predefinedtype:ifcfiltertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowtreatmentdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcfiltertypeenum): + self._predefinedtype = ifcfiltertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcfiltertypeenum.self.userdefined) or ((self.predefinedtype == ifcfiltertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcspace # +#################### +class ifcspace(ifcspatialstructureelement): + '''Entity ifcspace definition. + + :param interiororexteriorspace + :type interiororexteriorspace:ifcinternalorexternalenum + + :param elevationwithflooring + :type elevationwithflooring:ifclengthmeasure + + :param hascoverings + :type hascoverings:SET(0,None,'ifcrelcoversspaces', scope = schema_scope) + + :param boundedby + :type boundedby:SET(0,None,'ifcrelspaceboundary', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , interiororexteriorspace,elevationwithflooring, ): + ifcspatialstructureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , ) + self.interiororexteriorspace = interiororexteriorspace + self.elevationwithflooring = elevationwithflooring + + @apply + def interiororexteriorspace(): + def fget( self ): + return self._interiororexteriorspace + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument interiororexteriorspace is mantatory and can not be set to None') + if not check_type(value,ifcinternalorexternalenum): + self._interiororexteriorspace = ifcinternalorexternalenum(value) + else: + self._interiororexteriorspace = value + return property(**locals()) + + @apply + def elevationwithflooring(): + def fget( self ): + return self._elevationwithflooring + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._elevationwithflooring = ifclengthmeasure(value) + else: + self._elevationwithflooring = value + else: + self._elevationwithflooring = value + return property(**locals()) + + @apply + def hascoverings(): + def fget( self ): + return self._hascoverings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hascoverings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def boundedby(): + def fget( self ): + return self._boundedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument boundedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcflowterminal # +#################### +class ifcflowterminal(ifcdistributionflowelement): + '''Entity ifcflowterminal definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcpolyloop # +#################### +class ifcpolyloop(ifcloop): + '''Entity ifcpolyloop definition. + + :param polygon + :type polygon:LIST(3,None,'ifccartesianpoint', scope = schema_scope) + ''' + def __init__( self , polygon, ): + ifcloop.__init__(self , ) + self.polygon = polygon + + @apply + def polygon(): + def fget( self ): + return self._polygon + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument polygon is mantatory and can not be set to None') + if not check_type(value,LIST(3,None,'ifccartesianpoint', scope = schema_scope)): + self._polygon = LIST(value) + else: + self._polygon = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcrelassociatesmaterial # +#################### +class ifcrelassociatesmaterial(ifcrelassociates): + '''Entity ifcrelassociatesmaterial definition. + + :param relatingmaterial + :type relatingmaterial:ifcmaterialselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingmaterial, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingmaterial = relatingmaterial + + @apply + def relatingmaterial(): + def fget( self ): + return self._relatingmaterial + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingmaterial is mantatory and can not be set to None') + if not check_type(value,ifcmaterialselect): + self._relatingmaterial = ifcmaterialselect(value) + else: + self._relatingmaterial = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (SIZEOF(None) == 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifccshapeprofiledef # +#################### +class ifccshapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifccshapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param width + :type width:ifcpositivelengthmeasure + + :param wallthickness + :type wallthickness:ifcpositivelengthmeasure + + :param girth + :type girth:ifcpositivelengthmeasure + + :param internalfilletradius + :type internalfilletradius:ifcpositivelengthmeasure + + :param centreofgravityinx + :type centreofgravityinx:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,width,wallthickness,girth,internalfilletradius,centreofgravityinx, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.width = width + self.wallthickness = wallthickness + self.girth = girth + self.internalfilletradius = internalfilletradius + self.centreofgravityinx = centreofgravityinx + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def width(): + def fget( self ): + return self._width + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument width is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._width = ifcpositivelengthmeasure(value) + else: + self._width = value + return property(**locals()) + + @apply + def wallthickness(): + def fget( self ): + return self._wallthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument wallthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._wallthickness = ifcpositivelengthmeasure(value) + else: + self._wallthickness = value + return property(**locals()) + + @apply + def girth(): + def fget( self ): + return self._girth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument girth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._girth = ifcpositivelengthmeasure(value) + else: + self._girth = value + return property(**locals()) + + @apply + def internalfilletradius(): + def fget( self ): + return self._internalfilletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._internalfilletradius = ifcpositivelengthmeasure(value) + else: + self._internalfilletradius = value + else: + self._internalfilletradius = value + return property(**locals()) + + @apply + def centreofgravityinx(): + def fget( self ): + return self._centreofgravityinx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._centreofgravityinx = ifcpositivelengthmeasure(value) + else: + self._centreofgravityinx = value + else: + self._centreofgravityinx = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.girth < (self.depth / 2)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (( not EXISTS(self.internalfilletradius)) or ((self.internalfilletradius <= (self.width / 2)) and (self.internalfilletradius <= (self.depth / 2)))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ((self.wallthickness < (self.width / 2)) and (self.wallthickness < (self.depth / 2))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcpropertytablevalue # +#################### +class ifcpropertytablevalue(ifcsimpleproperty): + '''Entity ifcpropertytablevalue definition. + + :param definingvalues + :type definingvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param definedvalues + :type definedvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param expression + :type expression:ifctext + + :param definingunit + :type definingunit:ifcunit + + :param definedunit + :type definedunit:ifcunit + ''' + def __init__( self , inherited0__name , inherited1__description , definingvalues,definedvalues,expression,definingunit,definedunit, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.definingvalues = definingvalues + self.definedvalues = definedvalues + self.expression = expression + self.definingunit = definingunit + self.definedunit = definedunit + + @apply + def definingvalues(): + def fget( self ): + return self._definingvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definingvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._definingvalues = LIST(value) + else: + self._definingvalues = value + return property(**locals()) + + @apply + def definedvalues(): + def fget( self ): + return self._definedvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument definedvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._definedvalues = LIST(value) + else: + self._definedvalues = value + return property(**locals()) + + @apply + def expression(): + def fget( self ): + return self._expression + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._expression = ifctext(value) + else: + self._expression = value + else: + self._expression = value + return property(**locals()) + + @apply + def definingunit(): + def fget( self ): + return self._definingunit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._definingunit = ifcunit(value) + else: + self._definingunit = value + else: + self._definingunit = value + return property(**locals()) + + @apply + def definedunit(): + def fget( self ): + return self._definedunit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._definedunit = ifcunit(value) + else: + self._definedunit = value + else: + self._definedunit = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(self.definingvalues) == SIZEOF(self.definedvalues)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcstructuralloadplanarforce # +#################### +class ifcstructuralloadplanarforce(ifcstructuralloadstatic): + '''Entity ifcstructuralloadplanarforce definition. + + :param planarforcex + :type planarforcex:ifcplanarforcemeasure + + :param planarforcey + :type planarforcey:ifcplanarforcemeasure + + :param planarforcez + :type planarforcez:ifcplanarforcemeasure + ''' + def __init__( self , inherited0__name , planarforcex,planarforcey,planarforcez, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.planarforcex = planarforcex + self.planarforcey = planarforcey + self.planarforcez = planarforcez + + @apply + def planarforcex(): + def fget( self ): + return self._planarforcex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplanarforcemeasure): + self._planarforcex = ifcplanarforcemeasure(value) + else: + self._planarforcex = value + else: + self._planarforcex = value + return property(**locals()) + + @apply + def planarforcey(): + def fget( self ): + return self._planarforcey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplanarforcemeasure): + self._planarforcey = ifcplanarforcemeasure(value) + else: + self._planarforcey = value + else: + self._planarforcey = value + return property(**locals()) + + @apply + def planarforcez(): + def fget( self ): + return self._planarforcez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplanarforcemeasure): + self._planarforcez = ifcplanarforcemeasure(value) + else: + self._planarforcez = value + else: + self._planarforcez = value + return property(**locals()) + +#################### + # ENTITY ifcbooleanclippingresult # +#################### +class ifcbooleanclippingresult(ifcbooleanresult): + '''Entity ifcbooleanclippingresult definition. + ''' + def __init__( self , inherited0__operator , inherited1__firstoperand , inherited2__secondoperand , ): + ifcbooleanresult.__init__(self , inherited0__operator , inherited1__firstoperand , inherited2__secondoperand , ) + def wr1(self): + eval_wr1_wr = (('IFC2X3.IFCSWEPTAREASOLID' == TYPEOF(self.firstoperand)) or ('IFC2X3.IFCBOOLEANCLIPPINGRESULT' == TYPEOF(self.firstoperand))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ('IFC2X3.IFCHALFSPACESOLID' == TYPEOF(self.secondoperand)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (self.operator == difference) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcbuildingstorey # +#################### +class ifcbuildingstorey(ifcspatialstructureelement): + '''Entity ifcbuildingstorey definition. + + :param elevation + :type elevation:ifclengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , elevation, ): + ifcspatialstructureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , ) + self.elevation = elevation + + @apply + def elevation(): + def fget( self ): + return self._elevation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._elevation = ifclengthmeasure(value) + else: + self._elevation = value + else: + self._elevation = value + return property(**locals()) + +#################### + # ENTITY ifcsectionreinforcementproperties # +#################### +class ifcsectionreinforcementproperties(BaseEntityClass): + '''Entity ifcsectionreinforcementproperties definition. + + :param longitudinalstartposition + :type longitudinalstartposition:ifclengthmeasure + + :param longitudinalendposition + :type longitudinalendposition:ifclengthmeasure + + :param transverseposition + :type transverseposition:ifclengthmeasure + + :param reinforcementrole + :type reinforcementrole:ifcreinforcingbarroleenum + + :param sectiondefinition + :type sectiondefinition:ifcsectionproperties + + :param crosssectionreinforcementdefinitions + :type crosssectionreinforcementdefinitions:SET(1,None,'ifcreinforcementbarproperties', scope = schema_scope) + ''' + def __init__( self , longitudinalstartposition,longitudinalendposition,transverseposition,reinforcementrole,sectiondefinition,crosssectionreinforcementdefinitions, ): + self.longitudinalstartposition = longitudinalstartposition + self.longitudinalendposition = longitudinalendposition + self.transverseposition = transverseposition + self.reinforcementrole = reinforcementrole + self.sectiondefinition = sectiondefinition + self.crosssectionreinforcementdefinitions = crosssectionreinforcementdefinitions + + @apply + def longitudinalstartposition(): + def fget( self ): + return self._longitudinalstartposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument longitudinalstartposition is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._longitudinalstartposition = ifclengthmeasure(value) + else: + self._longitudinalstartposition = value + return property(**locals()) + + @apply + def longitudinalendposition(): + def fget( self ): + return self._longitudinalendposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument longitudinalendposition is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._longitudinalendposition = ifclengthmeasure(value) + else: + self._longitudinalendposition = value + return property(**locals()) + + @apply + def transverseposition(): + def fget( self ): + return self._transverseposition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._transverseposition = ifclengthmeasure(value) + else: + self._transverseposition = value + else: + self._transverseposition = value + return property(**locals()) + + @apply + def reinforcementrole(): + def fget( self ): + return self._reinforcementrole + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reinforcementrole is mantatory and can not be set to None') + if not check_type(value,ifcreinforcingbarroleenum): + self._reinforcementrole = ifcreinforcingbarroleenum(value) + else: + self._reinforcementrole = value + return property(**locals()) + + @apply + def sectiondefinition(): + def fget( self ): + return self._sectiondefinition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sectiondefinition is mantatory and can not be set to None') + if not check_type(value,ifcsectionproperties): + self._sectiondefinition = ifcsectionproperties(value) + else: + self._sectiondefinition = value + return property(**locals()) + + @apply + def crosssectionreinforcementdefinitions(): + def fget( self ): + return self._crosssectionreinforcementdefinitions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument crosssectionreinforcementdefinitions is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcreinforcementbarproperties', scope = schema_scope)): + self._crosssectionreinforcementdefinitions = SET(value) + else: + self._crosssectionreinforcementdefinitions = value + return property(**locals()) + +#################### + # ENTITY ifcrelassignstoresource # +#################### +class ifcrelassignstoresource(ifcrelassigns): + '''Entity ifcrelassignstoresource definition. + + :param relatingresource + :type relatingresource:ifcresource + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingresource, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingresource = relatingresource + + @apply + def relatingresource(): + def fget( self ): + return self._relatingresource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingresource is mantatory and can not be set to None') + if not check_type(value,ifcresource): + self._relatingresource = ifcresource(value) + else: + self._relatingresource = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifclineardimension # +#################### +class ifclineardimension(ifcdimensioncurvedirectedcallout): + '''Entity ifclineardimension definition. + ''' + def __init__( self , inherited0__contents , ): + ifcdimensioncurvedirectedcallout.__init__(self , inherited0__contents , ) + +#################### + # ENTITY ifcprocedure # +#################### +class ifcprocedure(ifcprocess): + '''Entity ifcprocedure definition. + + :param procedureid + :type procedureid:ifcidentifier + + :param proceduretype + :type proceduretype:ifcproceduretypeenum + + :param userdefinedproceduretype + :type userdefinedproceduretype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , procedureid,proceduretype,userdefinedproceduretype, ): + ifcprocess.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.procedureid = procedureid + self.proceduretype = proceduretype + self.userdefinedproceduretype = userdefinedproceduretype + + @apply + def procedureid(): + def fget( self ): + return self._procedureid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument procedureid is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._procedureid = ifcidentifier(value) + else: + self._procedureid = value + return property(**locals()) + + @apply + def proceduretype(): + def fget( self ): + return self._proceduretype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument proceduretype is mantatory and can not be set to None') + if not check_type(value,ifcproceduretypeenum): + self._proceduretype = ifcproceduretypeenum(value) + else: + self._proceduretype = value + return property(**locals()) + + @apply + def userdefinedproceduretype(): + def fget( self ): + return self._userdefinedproceduretype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedproceduretype = ifclabel(value) + else: + self._userdefinedproceduretype = value + else: + self._userdefinedproceduretype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + def wr4(self): + eval_wr4_wr = ((self.proceduretype != ifcproceduretypeenum.self.userdefined) or ((self.proceduretype == ifcproceduretypeenum.self.userdefined) and EXISTS(self.self.ifcprocedure.self.userdefinedproceduretype))) + if not eval_wr4_wr: + raise AssertionError('Rule wr4 violated') + else: + return eval_wr4_wr + + +#################### + # ENTITY ifcactionrequest # +#################### +class ifcactionrequest(ifccontrol): + '''Entity ifcactionrequest definition. + + :param requestid + :type requestid:ifcidentifier + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , requestid, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.requestid = requestid + + @apply + def requestid(): + def fget( self ): + return self._requestid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument requestid is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._requestid = ifcidentifier(value) + else: + self._requestid = value + return property(**locals()) + +#################### + # ENTITY ifcinventory # +#################### +class ifcinventory(ifcgroup): + '''Entity ifcinventory definition. + + :param inventorytype + :type inventorytype:ifcinventorytypeenum + + :param jurisdiction + :type jurisdiction:ifcactorselect + + :param responsiblepersons + :type responsiblepersons:SET(1,None,'ifcperson', scope = schema_scope) + + :param lastupdatedate + :type lastupdatedate:ifccalendardate + + :param currentvalue + :type currentvalue:ifccostvalue + + :param originalvalue + :type originalvalue:ifccostvalue + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inventorytype,jurisdiction,responsiblepersons,lastupdatedate,currentvalue,originalvalue, ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.inventorytype = inventorytype + self.jurisdiction = jurisdiction + self.responsiblepersons = responsiblepersons + self.lastupdatedate = lastupdatedate + self.currentvalue = currentvalue + self.originalvalue = originalvalue + + @apply + def inventorytype(): + def fget( self ): + return self._inventorytype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument inventorytype is mantatory and can not be set to None') + if not check_type(value,ifcinventorytypeenum): + self._inventorytype = ifcinventorytypeenum(value) + else: + self._inventorytype = value + return property(**locals()) + + @apply + def jurisdiction(): + def fget( self ): + return self._jurisdiction + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument jurisdiction is mantatory and can not be set to None') + if not check_type(value,ifcactorselect): + self._jurisdiction = ifcactorselect(value) + else: + self._jurisdiction = value + return property(**locals()) + + @apply + def responsiblepersons(): + def fget( self ): + return self._responsiblepersons + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument responsiblepersons is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcperson', scope = schema_scope)): + self._responsiblepersons = SET(value) + else: + self._responsiblepersons = value + return property(**locals()) + + @apply + def lastupdatedate(): + def fget( self ): + return self._lastupdatedate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lastupdatedate is mantatory and can not be set to None') + if not check_type(value,ifccalendardate): + self._lastupdatedate = ifccalendardate(value) + else: + self._lastupdatedate = value + return property(**locals()) + + @apply + def currentvalue(): + def fget( self ): + return self._currentvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostvalue): + self._currentvalue = ifccostvalue(value) + else: + self._currentvalue = value + else: + self._currentvalue = value + return property(**locals()) + + @apply + def originalvalue(): + def fget( self ): + return self._originalvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostvalue): + self._originalvalue = ifccostvalue(value) + else: + self._originalvalue = value + else: + self._originalvalue = value + return property(**locals()) + def wr41(self): + eval_wr41_wr = (SIZEOF(None) == 0) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + +#################### + # ENTITY ifcclassificationitemrelationship # +#################### +class ifcclassificationitemrelationship(BaseEntityClass): + '''Entity ifcclassificationitemrelationship definition. + + :param relatingitem + :type relatingitem:ifcclassificationitem + + :param relateditems + :type relateditems:SET(1,None,'ifcclassificationitem', scope = schema_scope) + ''' + def __init__( self , relatingitem,relateditems, ): + self.relatingitem = relatingitem + self.relateditems = relateditems + + @apply + def relatingitem(): + def fget( self ): + return self._relatingitem + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingitem is mantatory and can not be set to None') + if not check_type(value,ifcclassificationitem): + self._relatingitem = ifcclassificationitem(value) + else: + self._relatingitem = value + return property(**locals()) + + @apply + def relateditems(): + def fget( self ): + return self._relateditems + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relateditems is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcclassificationitem', scope = schema_scope)): + self._relateditems = SET(value) + else: + self._relateditems = value + return property(**locals()) + +#################### + # ENTITY ifcpredefinedterminatorsymbol # +#################### +class ifcpredefinedterminatorsymbol(ifcpredefinedsymbol): + '''Entity ifcpredefinedterminatorsymbol definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefinedsymbol.__init__(self , inherited0__name , ) + def wr31(self): + eval_wr31_wr = (self.self.ifcpredefineditem.self.name == ['blanked arrow','blanked box','blanked dot','dimension origin','filled arrow','filled box','filled dot','integral symbol','open arrow','slash','unfilled arrow']) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcrelconnectspathelements # +#################### +class ifcrelconnectspathelements(ifcrelconnectselements): + '''Entity ifcrelconnectspathelements definition. + + :param relatingpriorities + :type relatingpriorities:LIST(0,None,'INTEGER', scope = schema_scope) + + :param relatedpriorities + :type relatedpriorities:LIST(0,None,'INTEGER', scope = schema_scope) + + :param relatedconnectiontype + :type relatedconnectiontype:ifcconnectiontypeenum + + :param relatingconnectiontype + :type relatingconnectiontype:ifcconnectiontypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__connectiongeometry , inherited5__relatingelement , inherited6__relatedelement , relatingpriorities,relatedpriorities,relatedconnectiontype,relatingconnectiontype, ): + ifcrelconnectselements.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__connectiongeometry , inherited5__relatingelement , inherited6__relatedelement , ) + self.relatingpriorities = relatingpriorities + self.relatedpriorities = relatedpriorities + self.relatedconnectiontype = relatedconnectiontype + self.relatingconnectiontype = relatingconnectiontype + + @apply + def relatingpriorities(): + def fget( self ): + return self._relatingpriorities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingpriorities is mantatory and can not be set to None') + if not check_type(value,LIST(0,None,'INTEGER', scope = schema_scope)): + self._relatingpriorities = LIST(value) + else: + self._relatingpriorities = value + return property(**locals()) + + @apply + def relatedpriorities(): + def fget( self ): + return self._relatedpriorities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedpriorities is mantatory and can not be set to None') + if not check_type(value,LIST(0,None,'INTEGER', scope = schema_scope)): + self._relatedpriorities = LIST(value) + else: + self._relatedpriorities = value + return property(**locals()) + + @apply + def relatedconnectiontype(): + def fget( self ): + return self._relatedconnectiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedconnectiontype is mantatory and can not be set to None') + if not check_type(value,ifcconnectiontypeenum): + self._relatedconnectiontype = ifcconnectiontypeenum(value) + else: + self._relatedconnectiontype = value + return property(**locals()) + + @apply + def relatingconnectiontype(): + def fget( self ): + return self._relatingconnectiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingconnectiontype is mantatory and can not be set to None') + if not check_type(value,ifcconnectiontypeenum): + self._relatingconnectiontype = ifcconnectiontypeenum(value) + else: + self._relatingconnectiontype = value + return property(**locals()) + +#################### + # ENTITY ifccurtainwalltype # +#################### +class ifccurtainwalltype(ifcbuildingelementtype): + '''Entity ifccurtainwalltype definition. + + :param predefinedtype + :type predefinedtype:ifccurtainwalltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccurtainwalltypeenum): + self._predefinedtype = ifccurtainwalltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcdraughtingpredefinedcurvefont # +#################### +class ifcdraughtingpredefinedcurvefont(ifcpredefinedcurvefont): + '''Entity ifcdraughtingpredefinedcurvefont definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefinedcurvefont.__init__(self , inherited0__name , ) + def wr31(self): + eval_wr31_wr = (self.self.ifcpredefineditem.self.name == ['continuous','chain','chain double dash','dashed','dotted','by layer']) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcrelcoversbldgelements # +#################### +class ifcrelcoversbldgelements(ifcrelconnects): + '''Entity ifcrelcoversbldgelements definition. + + :param relatingbuildingelement + :type relatingbuildingelement:ifcelement + + :param relatedcoverings + :type relatedcoverings:SET(1,None,'ifccovering', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingbuildingelement,relatedcoverings, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingbuildingelement = relatingbuildingelement + self.relatedcoverings = relatedcoverings + + @apply + def relatingbuildingelement(): + def fget( self ): + return self._relatingbuildingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingbuildingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingbuildingelement = ifcelement(value) + else: + self._relatingbuildingelement = value + return property(**locals()) + + @apply + def relatedcoverings(): + def fget( self ): + return self._relatedcoverings + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedcoverings is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifccovering', scope = schema_scope)): + self._relatedcoverings = SET(value) + else: + self._relatedcoverings = value + return property(**locals()) + +#################### + # ENTITY ifcdoorstyle # +#################### +class ifcdoorstyle(ifctypeproduct): + '''Entity ifcdoorstyle definition. + + :param operationtype + :type operationtype:ifcdoorstyleoperationenum + + :param constructiontype + :type constructiontype:ifcdoorstyleconstructionenum + + :param parametertakesprecedence + :type parametertakesprecedence:BOOLEAN + + :param sizeable + :type sizeable:BOOLEAN + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , operationtype,constructiontype,parametertakesprecedence,sizeable, ): + ifctypeproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , ) + self.operationtype = operationtype + self.constructiontype = constructiontype + self.parametertakesprecedence = parametertakesprecedence + self.sizeable = sizeable + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operationtype is mantatory and can not be set to None') + if not check_type(value,ifcdoorstyleoperationenum): + self._operationtype = ifcdoorstyleoperationenum(value) + else: + self._operationtype = value + return property(**locals()) + + @apply + def constructiontype(): + def fget( self ): + return self._constructiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constructiontype is mantatory and can not be set to None') + if not check_type(value,ifcdoorstyleconstructionenum): + self._constructiontype = ifcdoorstyleconstructionenum(value) + else: + self._constructiontype = value + return property(**locals()) + + @apply + def parametertakesprecedence(): + def fget( self ): + return self._parametertakesprecedence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parametertakesprecedence is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._parametertakesprecedence = BOOLEAN(value) + else: + self._parametertakesprecedence = value + return property(**locals()) + + @apply + def sizeable(): + def fget( self ): + return self._sizeable + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sizeable is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._sizeable = BOOLEAN(value) + else: + self._sizeable = value + return property(**locals()) + +#################### + # ENTITY ifcellipse # +#################### +class ifcellipse(ifcconic): + '''Entity ifcellipse definition. + + :param semiaxis1 + :type semiaxis1:ifcpositivelengthmeasure + + :param semiaxis2 + :type semiaxis2:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , semiaxis1,semiaxis2, ): + ifcconic.__init__(self , inherited0__position , ) + self.semiaxis1 = semiaxis1 + self.semiaxis2 = semiaxis2 + + @apply + def semiaxis1(): + def fget( self ): + return self._semiaxis1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semiaxis1 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._semiaxis1 = ifcpositivelengthmeasure(value) + else: + self._semiaxis1 = value + return property(**locals()) + + @apply + def semiaxis2(): + def fget( self ): + return self._semiaxis2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semiaxis2 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._semiaxis2 = ifcpositivelengthmeasure(value) + else: + self._semiaxis2 = value + return property(**locals()) + +#################### + # ENTITY ifcstairflighttype # +#################### +class ifcstairflighttype(ifcbuildingelementtype): + '''Entity ifcstairflighttype definition. + + :param predefinedtype + :type predefinedtype:ifcstairflighttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstairflighttypeenum): + self._predefinedtype = ifcstairflighttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralloadtemperature # +#################### +class ifcstructuralloadtemperature(ifcstructuralloadstatic): + '''Entity ifcstructuralloadtemperature definition. + + :param deltat_constant + :type deltat_constant:ifcthermodynamictemperaturemeasure + + :param deltat_y + :type deltat_y:ifcthermodynamictemperaturemeasure + + :param deltat_z + :type deltat_z:ifcthermodynamictemperaturemeasure + ''' + def __init__( self , inherited0__name , deltat_constant,deltat_y,deltat_z, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.deltat_constant = deltat_constant + self.deltat_y = deltat_y + self.deltat_z = deltat_z + + @apply + def deltat_constant(): + def fget( self ): + return self._deltat_constant + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._deltat_constant = ifcthermodynamictemperaturemeasure(value) + else: + self._deltat_constant = value + else: + self._deltat_constant = value + return property(**locals()) + + @apply + def deltat_y(): + def fget( self ): + return self._deltat_y + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._deltat_y = ifcthermodynamictemperaturemeasure(value) + else: + self._deltat_y = value + else: + self._deltat_y = value + return property(**locals()) + + @apply + def deltat_z(): + def fget( self ): + return self._deltat_z + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._deltat_z = ifcthermodynamictemperaturemeasure(value) + else: + self._deltat_z = value + else: + self._deltat_z = value + return property(**locals()) + +#################### + # ENTITY ifcapprovalactorrelationship # +#################### +class ifcapprovalactorrelationship(BaseEntityClass): + '''Entity ifcapprovalactorrelationship definition. + + :param actor + :type actor:ifcactorselect + + :param approval + :type approval:ifcapproval + + :param role + :type role:ifcactorrole + ''' + def __init__( self , actor,approval,role, ): + self.actor = actor + self.approval = approval + self.role = role + + @apply + def actor(): + def fget( self ): + return self._actor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actor is mantatory and can not be set to None') + if not check_type(value,ifcactorselect): + self._actor = ifcactorselect(value) + else: + self._actor = value + return property(**locals()) + + @apply + def approval(): + def fget( self ): + return self._approval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument approval is mantatory and can not be set to None') + if not check_type(value,ifcapproval): + self._approval = ifcapproval(value) + else: + self._approval = value + return property(**locals()) + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,ifcactorrole): + self._role = ifcactorrole(value) + else: + self._role = value + return property(**locals()) + +#################### + # ENTITY ifclshapeprofiledef # +#################### +class ifclshapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifclshapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param width + :type width:ifcpositivelengthmeasure + + :param thickness + :type thickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcpositivelengthmeasure + + :param edgeradius + :type edgeradius:ifcpositivelengthmeasure + + :param legslope + :type legslope:ifcplaneanglemeasure + + :param centreofgravityinx + :type centreofgravityinx:ifcpositivelengthmeasure + + :param centreofgravityiny + :type centreofgravityiny:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,width,thickness,filletradius,edgeradius,legslope,centreofgravityinx,centreofgravityiny, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.width = width + self.thickness = thickness + self.filletradius = filletradius + self.edgeradius = edgeradius + self.legslope = legslope + self.centreofgravityinx = centreofgravityinx + self.centreofgravityiny = centreofgravityiny + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def width(): + def fget( self ): + return self._width + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._width = ifcpositivelengthmeasure(value) + else: + self._width = value + else: + self._width = value + return property(**locals()) + + @apply + def thickness(): + def fget( self ): + return self._thickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument thickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._thickness = ifcpositivelengthmeasure(value) + else: + self._thickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._filletradius = ifcpositivelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + + @apply + def edgeradius(): + def fget( self ): + return self._edgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._edgeradius = ifcpositivelengthmeasure(value) + else: + self._edgeradius = value + else: + self._edgeradius = value + return property(**locals()) + + @apply + def legslope(): + def fget( self ): + return self._legslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._legslope = ifcplaneanglemeasure(value) + else: + self._legslope = value + else: + self._legslope = value + return property(**locals()) + + @apply + def centreofgravityinx(): + def fget( self ): + return self._centreofgravityinx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._centreofgravityinx = ifcpositivelengthmeasure(value) + else: + self._centreofgravityinx = value + else: + self._centreofgravityinx = value + return property(**locals()) + + @apply + def centreofgravityiny(): + def fget( self ): + return self._centreofgravityiny + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._centreofgravityiny = ifcpositivelengthmeasure(value) + else: + self._centreofgravityiny = value + else: + self._centreofgravityiny = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (self.thickness < self.depth) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (( not EXISTS(self.width)) or (self.thickness < self.width)) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcflowinstrumenttype # +#################### +class ifcflowinstrumenttype(ifcdistributioncontrolelementtype): + '''Entity ifcflowinstrumenttype definition. + + :param predefinedtype + :type predefinedtype:ifcflowinstrumenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcflowinstrumenttypeenum): + self._predefinedtype = ifcflowinstrumenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifccircle # +#################### +class ifccircle(ifcconic): + '''Entity ifccircle definition. + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , radius, ): + ifcconic.__init__(self , inherited0__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifcdistributionchamberelement # +#################### +class ifcdistributionchamberelement(ifcdistributionflowelement): + '''Entity ifcdistributionchamberelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcmotorconnectiontype # +#################### +class ifcmotorconnectiontype(ifcenergyconversiondevicetype): + '''Entity ifcmotorconnectiontype definition. + + :param predefinedtype + :type predefinedtype:ifcmotorconnectiontypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcmotorconnectiontypeenum): + self._predefinedtype = ifcmotorconnectiontypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcshellbasedsurfacemodel # +#################### +class ifcshellbasedsurfacemodel(ifcgeometricrepresentationitem): + '''Entity ifcshellbasedsurfacemodel definition. + + :param sbsmboundary + :type sbsmboundary:SET(1,None,'ifcshell', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , sbsmboundary, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.sbsmboundary = sbsmboundary + + @apply + def sbsmboundary(): + def fget( self ): + return self._sbsmboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sbsmboundary is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcshell', scope = schema_scope)): + self._sbsmboundary = SET(value) + else: + self._sbsmboundary = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcprojectorder # +#################### +class ifcprojectorder(ifccontrol): + '''Entity ifcprojectorder definition. + + :param id + :type id:ifcidentifier + + :param predefinedtype + :type predefinedtype:ifcprojectordertypeenum + + :param status + :type status:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , id,predefinedtype,status, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.id = id + self.predefinedtype = predefinedtype + self.status = status + + @apply + def id(): + def fget( self ): + return self._id + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument id is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._id = ifcidentifier(value) + else: + self._id = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcprojectordertypeenum): + self._predefinedtype = ifcprojectordertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._status = ifclabel(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + +#################### + # ENTITY ifcrampflighttype # +#################### +class ifcrampflighttype(ifcbuildingelementtype): + '''Entity ifcrampflighttype definition. + + :param predefinedtype + :type predefinedtype:ifcrampflighttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcrampflighttypeenum): + self._predefinedtype = ifcrampflighttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacecurvesweptareasolid # +#################### +class ifcsurfacecurvesweptareasolid(ifcsweptareasolid): + '''Entity ifcsurfacecurvesweptareasolid definition. + + :param directrix + :type directrix:ifccurve + + :param startparam + :type startparam:ifcparametervalue + + :param endparam + :type endparam:ifcparametervalue + + :param referencesurface + :type referencesurface:ifcsurface + ''' + def __init__( self , inherited0__sweptarea , inherited1__position , directrix,startparam,endparam,referencesurface, ): + ifcsweptareasolid.__init__(self , inherited0__sweptarea , inherited1__position , ) + self.directrix = directrix + self.startparam = startparam + self.endparam = endparam + self.referencesurface = referencesurface + + @apply + def directrix(): + def fget( self ): + return self._directrix + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directrix is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._directrix = ifccurve(value) + else: + self._directrix = value + return property(**locals()) + + @apply + def startparam(): + def fget( self ): + return self._startparam + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument startparam is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._startparam = ifcparametervalue(value) + else: + self._startparam = value + return property(**locals()) + + @apply + def endparam(): + def fget( self ): + return self._endparam + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument endparam is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._endparam = ifcparametervalue(value) + else: + self._endparam = value + return property(**locals()) + + @apply + def referencesurface(): + def fget( self ): + return self._referencesurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument referencesurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._referencesurface = ifcsurface(value) + else: + self._referencesurface = value + return property(**locals()) + +#################### + # ENTITY ifctextstylewithboxcharacteristics # +#################### +class ifctextstylewithboxcharacteristics(BaseEntityClass): + '''Entity ifctextstylewithboxcharacteristics definition. + + :param boxheight + :type boxheight:ifcpositivelengthmeasure + + :param boxwidth + :type boxwidth:ifcpositivelengthmeasure + + :param boxslantangle + :type boxslantangle:ifcplaneanglemeasure + + :param boxrotateangle + :type boxrotateangle:ifcplaneanglemeasure + + :param characterspacing + :type characterspacing:ifcsizeselect + ''' + def __init__( self , boxheight,boxwidth,boxslantangle,boxrotateangle,characterspacing, ): + self.boxheight = boxheight + self.boxwidth = boxwidth + self.boxslantangle = boxslantangle + self.boxrotateangle = boxrotateangle + self.characterspacing = characterspacing + + @apply + def boxheight(): + def fget( self ): + return self._boxheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._boxheight = ifcpositivelengthmeasure(value) + else: + self._boxheight = value + else: + self._boxheight = value + return property(**locals()) + + @apply + def boxwidth(): + def fget( self ): + return self._boxwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._boxwidth = ifcpositivelengthmeasure(value) + else: + self._boxwidth = value + else: + self._boxwidth = value + return property(**locals()) + + @apply + def boxslantangle(): + def fget( self ): + return self._boxslantangle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._boxslantangle = ifcplaneanglemeasure(value) + else: + self._boxslantangle = value + else: + self._boxslantangle = value + return property(**locals()) + + @apply + def boxrotateangle(): + def fget( self ): + return self._boxrotateangle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._boxrotateangle = ifcplaneanglemeasure(value) + else: + self._boxrotateangle = value + else: + self._boxrotateangle = value + return property(**locals()) + + @apply + def characterspacing(): + def fget( self ): + return self._characterspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._characterspacing = ifcsizeselect(value) + else: + self._characterspacing = value + else: + self._characterspacing = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralpointaction # +#################### +class ifcstructuralpointaction(ifcstructuralaction): + '''Entity ifcstructuralpointaction definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , ): + ifcstructuralaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__causedby , ) + def wr61(self): + eval_wr61_wr = (SIZEOF(['IFC2X3.IFCSTRUCTURALLOADSINGLEFORCE','IFC2X3.IFCSTRUCTURALLOADSINGLEDISPLACEMENT'] * TYPEOF(self.self.ifcstructuralactivity.self.appliedload)) == 1) + if not eval_wr61_wr: + raise AssertionError('Rule wr61 violated') + else: + return eval_wr61_wr + + +#################### + # ENTITY ifcannotationsurface # +#################### +class ifcannotationsurface(ifcgeometricrepresentationitem): + '''Entity ifcannotationsurface definition. + + :param item + :type item:ifcgeometricrepresentationitem + + :param texturecoordinates + :type texturecoordinates:ifctexturecoordinate + ''' + def __init__( self , item,texturecoordinates, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.item = item + self.texturecoordinates = texturecoordinates + + @apply + def item(): + def fget( self ): + return self._item + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument item is mantatory and can not be set to None') + if not check_type(value,ifcgeometricrepresentationitem): + self._item = ifcgeometricrepresentationitem(value) + else: + self._item = value + return property(**locals()) + + @apply + def texturecoordinates(): + def fget( self ): + return self._texturecoordinates + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctexturecoordinate): + self._texturecoordinates = ifctexturecoordinate(value) + else: + self._texturecoordinates = value + else: + self._texturecoordinates = value + return property(**locals()) + def wr01(self): + eval_wr01_wr = (SIZEOF(['IFC2X3.IFCSURFACE','IFC2X3.IFCSHELLBASEDSURFACEMODEL','IFC2X3.IFCFACEBASEDSURFACEMODEL','IFC2X3.IFCSOLIDMODEL','IFC2X3.IFCBOOLEANRESULT','IFC2X3.IFCCSGPRIMITIVE3D'] * TYPEOF(self.item)) >= 1) + if not eval_wr01_wr: + raise AssertionError('Rule wr01 violated') + else: + return eval_wr01_wr + + +#################### + # ENTITY ifcpropertyreferencevalue # +#################### +class ifcpropertyreferencevalue(ifcsimpleproperty): + '''Entity ifcpropertyreferencevalue definition. + + :param usagename + :type usagename:ifclabel + + :param propertyreference + :type propertyreference:ifcobjectreferenceselect + ''' + def __init__( self , inherited0__name , inherited1__description , usagename,propertyreference, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.usagename = usagename + self.propertyreference = propertyreference + + @apply + def usagename(): + def fget( self ): + return self._usagename + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._usagename = ifclabel(value) + else: + self._usagename = value + else: + self._usagename = value + return property(**locals()) + + @apply + def propertyreference(): + def fget( self ): + return self._propertyreference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument propertyreference is mantatory and can not be set to None') + if not check_type(value,ifcobjectreferenceselect): + self._propertyreference = ifcobjectreferenceselect(value) + else: + self._propertyreference = value + return property(**locals()) + +#################### + # ENTITY ifcrelassignstoactor # +#################### +class ifcrelassignstoactor(ifcrelassigns): + '''Entity ifcrelassignstoactor definition. + + :param relatingactor + :type relatingactor:ifcactor + + :param actingrole + :type actingrole:ifcactorrole + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingactor,actingrole, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingactor = relatingactor + self.actingrole = actingrole + + @apply + def relatingactor(): + def fget( self ): + return self._relatingactor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingactor is mantatory and can not be set to None') + if not check_type(value,ifcactor): + self._relatingactor = ifcactor(value) + else: + self._relatingactor = value + return property(**locals()) + + @apply + def actingrole(): + def fget( self ): + return self._actingrole + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorrole): + self._actingrole = ifcactorrole(value) + else: + self._actingrole = value + else: + self._actingrole = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcreloccupiesspaces # +#################### +class ifcreloccupiesspaces(ifcrelassignstoactor): + '''Entity ifcreloccupiesspaces definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatingactor , inherited7__actingrole , ): + ifcrelassignstoactor.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatingactor , inherited7__actingrole , ) + +#################### + # ENTITY ifcpointonsurface # +#################### +class ifcpointonsurface(ifcpoint): + '''Entity ifcpointonsurface definition. + + :param basissurface + :type basissurface:ifcsurface + + :param pointparameteru + :type pointparameteru:ifcparametervalue + + :param pointparameterv + :type pointparameterv:ifcparametervalue + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , basissurface,pointparameteru,pointparameterv, ): + ifcpoint.__init__(self , ) + self.basissurface = basissurface + self.pointparameteru = pointparameteru + self.pointparameterv = pointparameterv + + @apply + def basissurface(): + def fget( self ): + return self._basissurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basissurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._basissurface = ifcsurface(value) + else: + self._basissurface = value + return property(**locals()) + + @apply + def pointparameteru(): + def fget( self ): + return self._pointparameteru + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pointparameteru is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._pointparameteru = ifcparametervalue(value) + else: + self._pointparameteru = value + return property(**locals()) + + @apply + def pointparameterv(): + def fget( self ): + return self._pointparameterv + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pointparameterv is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._pointparameterv = ifcparametervalue(value) + else: + self._pointparameterv = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.basissurface.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcboilertype # +#################### +class ifcboilertype(ifcenergyconversiondevicetype): + '''Entity ifcboilertype definition. + + :param predefinedtype + :type predefinedtype:ifcboilertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcboilertypeenum): + self._predefinedtype = ifcboilertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcboilertypeenum.self.userdefined) or ((self.predefinedtype == ifcboilertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcactor # +#################### +class ifcactor(ifcobject): + '''Entity ifcactor definition. + + :param theactor + :type theactor:ifcactorselect + + :param isactingupon + :type isactingupon:SET(0,None,'ifcrelassignstoactor', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , theactor, ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.theactor = theactor + + @apply + def theactor(): + def fget( self ): + return self._theactor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument theactor is mantatory and can not be set to None') + if not check_type(value,ifcactorselect): + self._theactor = ifcactorselect(value) + else: + self._theactor = value + return property(**locals()) + + @apply + def isactingupon(): + def fget( self ): + return self._isactingupon + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isactingupon is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcoccupant # +#################### +class ifcoccupant(ifcactor): + '''Entity ifcoccupant definition. + + :param predefinedtype + :type predefinedtype:ifcoccupanttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__theactor , predefinedtype, ): + ifcactor.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__theactor , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcoccupanttypeenum): + self._predefinedtype = ifcoccupanttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (( not (self.predefinedtype == ifcoccupanttypeenum.self.userdefined)) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcrelcontainedinspatialstructure # +#################### +class ifcrelcontainedinspatialstructure(ifcrelconnects): + '''Entity ifcrelcontainedinspatialstructure definition. + + :param relatedelements + :type relatedelements:SET(1,None,'ifcproduct', scope = schema_scope) + + :param relatingstructure + :type relatingstructure:ifcspatialstructureelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedelements,relatingstructure, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedelements = relatedelements + self.relatingstructure = relatingstructure + + @apply + def relatedelements(): + def fget( self ): + return self._relatedelements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedelements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproduct', scope = schema_scope)): + self._relatedelements = SET(value) + else: + self._relatedelements = value + return property(**locals()) + + @apply + def relatingstructure(): + def fget( self ): + return self._relatingstructure + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingstructure is mantatory and can not be set to None') + if not check_type(value,ifcspatialstructureelement): + self._relatingstructure = ifcspatialstructureelement(value) + else: + self._relatingstructure = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (SIZEOF(None) == 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcstructuralpointconnection # +#################### +class ifcstructuralpointconnection(ifcstructuralconnection): + '''Entity ifcstructuralpointconnection definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ): + ifcstructuralconnection.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ) + +#################### + # ENTITY ifcflowsegment # +#################### +class ifcflowsegment(ifcdistributionflowelement): + '''Entity ifcflowsegment definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcoffsetcurve3d # +#################### +class ifcoffsetcurve3d(ifccurve): + '''Entity ifcoffsetcurve3d definition. + + :param basiscurve + :type basiscurve:ifccurve + + :param distance + :type distance:ifclengthmeasure + + :param selfintersect + :type selfintersect:LOGICAL + + :param refdirection + :type refdirection:ifcdirection + ''' + def __init__( self , basiscurve,distance,selfintersect,refdirection, ): + ifccurve.__init__(self , ) + self.basiscurve = basiscurve + self.distance = distance + self.selfintersect = selfintersect + self.refdirection = refdirection + + @apply + def basiscurve(): + def fget( self ): + return self._basiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._basiscurve = ifccurve(value) + else: + self._basiscurve = value + return property(**locals()) + + @apply + def distance(): + def fget( self ): + return self._distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distance is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._distance = ifclengthmeasure(value) + else: + self._distance = value + return property(**locals()) + + @apply + def selfintersect(): + def fget( self ): + return self._selfintersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument selfintersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._selfintersect = LOGICAL(value) + else: + self._selfintersect = value + return property(**locals()) + + @apply + def refdirection(): + def fget( self ): + return self._refdirection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument refdirection is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._refdirection = ifcdirection(value) + else: + self._refdirection = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.basiscurve.self.dim == 3) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcvibrationisolatortype # +#################### +class ifcvibrationisolatortype(ifcdiscreteaccessorytype): + '''Entity ifcvibrationisolatortype definition. + + :param predefinedtype + :type predefinedtype:ifcvibrationisolatortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdiscreteaccessorytype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcvibrationisolatortypeenum): + self._predefinedtype = ifcvibrationisolatortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcvibrationisolatortypeenum.self.userdefined) or ((self.predefinedtype == ifcvibrationisolatortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcconversionbasedunit # +#################### +class ifcconversionbasedunit(ifcnamedunit): + '''Entity ifcconversionbasedunit definition. + + :param name + :type name:ifclabel + + :param conversionfactor + :type conversionfactor:ifcmeasurewithunit + ''' + def __init__( self , inherited0__dimensions , inherited1__unittype , name,conversionfactor, ): + ifcnamedunit.__init__(self , inherited0__dimensions , inherited1__unittype , ) + self.name = name + self.conversionfactor = conversionfactor + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def conversionfactor(): + def fget( self ): + return self._conversionfactor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument conversionfactor is mantatory and can not be set to None') + if not check_type(value,ifcmeasurewithunit): + self._conversionfactor = ifcmeasurewithunit(value) + else: + self._conversionfactor = value + return property(**locals()) + +#################### + # ENTITY ifctransformertype # +#################### +class ifctransformertype(ifcenergyconversiondevicetype): + '''Entity ifctransformertype definition. + + :param predefinedtype + :type predefinedtype:ifctransformertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctransformertypeenum): + self._predefinedtype = ifctransformertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcapplication # +#################### +class ifcapplication(BaseEntityClass): + '''Entity ifcapplication definition. + + :param applicationdeveloper + :type applicationdeveloper:ifcorganization + + :param version + :type version:ifclabel + + :param applicationfullname + :type applicationfullname:ifclabel + + :param applicationidentifier + :type applicationidentifier:ifcidentifier + ''' + def __init__( self , applicationdeveloper,version,applicationfullname,applicationidentifier, ): + self.applicationdeveloper = applicationdeveloper + self.version = version + self.applicationfullname = applicationfullname + self.applicationidentifier = applicationidentifier + + @apply + def applicationdeveloper(): + def fget( self ): + return self._applicationdeveloper + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applicationdeveloper is mantatory and can not be set to None') + if not check_type(value,ifcorganization): + self._applicationdeveloper = ifcorganization(value) + else: + self._applicationdeveloper = value + return property(**locals()) + + @apply + def version(): + def fget( self ): + return self._version + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument version is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._version = ifclabel(value) + else: + self._version = value + return property(**locals()) + + @apply + def applicationfullname(): + def fget( self ): + return self._applicationfullname + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applicationfullname is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._applicationfullname = ifclabel(value) + else: + self._applicationfullname = value + return property(**locals()) + + @apply + def applicationidentifier(): + def fget( self ): + return self._applicationidentifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applicationidentifier is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._applicationidentifier = ifcidentifier(value) + else: + self._applicationidentifier = value + return property(**locals()) + +#################### + # ENTITY ifcannotationfillareaoccurrence # +#################### +class ifcannotationfillareaoccurrence(ifcannotationoccurrence): + '''Entity ifcannotationfillareaoccurrence definition. + + :param fillstyletarget + :type fillstyletarget:ifcpoint + + :param globalorlocal + :type globalorlocal:ifcglobalorlocalenum + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , fillstyletarget,globalorlocal, ): + ifcannotationoccurrence.__init__(self , inherited0__item , inherited1__styles , inherited2__name , ) + self.fillstyletarget = fillstyletarget + self.globalorlocal = globalorlocal + + @apply + def fillstyletarget(): + def fget( self ): + return self._fillstyletarget + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpoint): + self._fillstyletarget = ifcpoint(value) + else: + self._fillstyletarget = value + else: + self._fillstyletarget = value + return property(**locals()) + + @apply + def globalorlocal(): + def fget( self ): + return self._globalorlocal + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcglobalorlocalenum): + self._globalorlocal = ifcglobalorlocalenum(value) + else: + self._globalorlocal = value + else: + self._globalorlocal = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (( not EXISTS(self.self.ifcstyleditem.self.item)) or ('IFC2X3.IFCANNOTATIONFILLAREA' == TYPEOF(self.self.ifcstyleditem.self.item))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifccoveringtype # +#################### +class ifccoveringtype(ifcbuildingelementtype): + '''Entity ifccoveringtype definition. + + :param predefinedtype + :type predefinedtype:ifccoveringtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccoveringtypeenum): + self._predefinedtype = ifccoveringtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcproductdefinitionshape # +#################### +class ifcproductdefinitionshape(ifcproductrepresentation): + '''Entity ifcproductdefinitionshape definition. + + :param shapeofproduct + :type shapeofproduct:SET(1,1,'ifcproduct', scope = schema_scope) + + :param hasshapeaspects + :type hasshapeaspects:SET(0,None,'ifcshapeaspect', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__representations , ): + ifcproductrepresentation.__init__(self , inherited0__name , inherited1__description , inherited2__representations , ) + + @apply + def shapeofproduct(): + def fget( self ): + return self._shapeofproduct + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument shapeofproduct is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasshapeaspects(): + def fget( self ): + return self._hasshapeaspects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasshapeaspects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr11(self): + eval_wr11_wr = (SIZEOF(None) == 0) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcangulardimension # +#################### +class ifcangulardimension(ifcdimensioncurvedirectedcallout): + '''Entity ifcangulardimension definition. + ''' + def __init__( self , inherited0__contents , ): + ifcdimensioncurvedirectedcallout.__init__(self , inherited0__contents , ) + +#################### + # ENTITY ifccirclehollowprofiledef # +#################### +class ifccirclehollowprofiledef(ifccircleprofiledef): + '''Entity ifccirclehollowprofiledef definition. + + :param wallthickness + :type wallthickness:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__radius , wallthickness, ): + ifccircleprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__radius , ) + self.wallthickness = wallthickness + + @apply + def wallthickness(): + def fget( self ): + return self._wallthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument wallthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._wallthickness = ifcpositivelengthmeasure(value) + else: + self._wallthickness = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.wallthickness < self.self.ifccircleprofiledef.self.radius) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccenterlineprofiledef # +#################### +class ifccenterlineprofiledef(ifcarbitraryopenprofiledef): + '''Entity ifccenterlineprofiledef definition. + + :param thickness + :type thickness:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__curve , thickness, ): + ifcarbitraryopenprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__curve , ) + self.thickness = thickness + + @apply + def thickness(): + def fget( self ): + return self._thickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument thickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._thickness = ifcpositivelengthmeasure(value) + else: + self._thickness = value + return property(**locals()) + +#################### + # ENTITY ifcfaceouterbound # +#################### +class ifcfaceouterbound(ifcfacebound): + '''Entity ifcfaceouterbound definition. + ''' + def __init__( self , inherited0__bound , inherited1__orientation , ): + ifcfacebound.__init__(self , inherited0__bound , inherited1__orientation , ) + +#################### + # ENTITY ifcvector # +#################### +class ifcvector(ifcgeometricrepresentationitem): + '''Entity ifcvector definition. + + :param orientation + :type orientation:ifcdirection + + :param magnitude + :type magnitude:ifclengthmeasure + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , orientation,magnitude, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.orientation = orientation + self.magnitude = magnitude + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._orientation = ifcdirection(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def magnitude(): + def fget( self ): + return self._magnitude + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument magnitude is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._magnitude = ifclengthmeasure(value) + else: + self._magnitude = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.orientation.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.magnitude >= 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifccurtainwall # +#################### +class ifccurtainwall(ifcbuildingelement): + '''Entity ifccurtainwall definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcexternallydefinedhatchstyle # +#################### +class ifcexternallydefinedhatchstyle(ifcexternalreference): + '''Entity ifcexternallydefinedhatchstyle definition. + ''' + def __init__( self , inherited0__location , inherited1__itemreference , inherited2__name , ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__itemreference , inherited2__name , ) + +#################### + # ENTITY ifcmeasurewithunit # +#################### +class ifcmeasurewithunit(BaseEntityClass): + '''Entity ifcmeasurewithunit definition. + + :param valuecomponent + :type valuecomponent:ifcvalue + + :param unitcomponent + :type unitcomponent:ifcunit + ''' + def __init__( self , valuecomponent,unitcomponent, ): + self.valuecomponent = valuecomponent + self.unitcomponent = unitcomponent + + @apply + def valuecomponent(): + def fget( self ): + return self._valuecomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument valuecomponent is mantatory and can not be set to None') + if not check_type(value,ifcvalue): + self._valuecomponent = ifcvalue(value) + else: + self._valuecomponent = value + return property(**locals()) + + @apply + def unitcomponent(): + def fget( self ): + return self._unitcomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unitcomponent is mantatory and can not be set to None') + if not check_type(value,ifcunit): + self._unitcomponent = ifcunit(value) + else: + self._unitcomponent = value + return property(**locals()) + +#################### + # ENTITY ifcrectangularpyramid # +#################### +class ifcrectangularpyramid(ifccsgprimitive3d): + '''Entity ifcrectangularpyramid definition. + + :param xlength + :type xlength:ifcpositivelengthmeasure + + :param ylength + :type ylength:ifcpositivelengthmeasure + + :param height + :type height:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , xlength,ylength,height, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.xlength = xlength + self.ylength = ylength + self.height = height + + @apply + def xlength(): + def fget( self ): + return self._xlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument xlength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._xlength = ifcpositivelengthmeasure(value) + else: + self._xlength = value + return property(**locals()) + + @apply + def ylength(): + def fget( self ): + return self._ylength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ylength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ylength = ifcpositivelengthmeasure(value) + else: + self._ylength = value + return property(**locals()) + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._height = ifcpositivelengthmeasure(value) + else: + self._height = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacestyle # +#################### +class ifcsurfacestyle(ifcpresentationstyle): + '''Entity ifcsurfacestyle definition. + + :param side + :type side:ifcsurfaceside + + :param styles + :type styles:SET(1,5,'ifcsurfacestyleelementselect', scope = schema_scope) + ''' + def __init__( self , inherited0__name , side,styles, ): + ifcpresentationstyle.__init__(self , inherited0__name , ) + self.side = side + self.styles = styles + + @apply + def side(): + def fget( self ): + return self._side + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument side is mantatory and can not be set to None') + if not check_type(value,ifcsurfaceside): + self._side = ifcsurfaceside(value) + else: + self._side = value + return property(**locals()) + + @apply + def styles(): + def fget( self ): + return self._styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styles is mantatory and can not be set to None') + if not check_type(value,SET(1,5,'ifcsurfacestyleelementselect', scope = schema_scope)): + self._styles = SET(value) + else: + self._styles = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (SIZEOF(None) <= 1) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (SIZEOF(None) <= 1) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + def wr13(self): + eval_wr13_wr = (SIZEOF(None) <= 1) + if not eval_wr13_wr: + raise AssertionError('Rule wr13 violated') + else: + return eval_wr13_wr + + def wr14(self): + eval_wr14_wr = (SIZEOF(None) <= 1) + if not eval_wr14_wr: + raise AssertionError('Rule wr14 violated') + else: + return eval_wr14_wr + + def wr15(self): + eval_wr15_wr = (SIZEOF(None) <= 1) + if not eval_wr15_wr: + raise AssertionError('Rule wr15 violated') + else: + return eval_wr15_wr + + +#################### + # ENTITY ifcelectricmotortype # +#################### +class ifcelectricmotortype(ifcenergyconversiondevicetype): + '''Entity ifcelectricmotortype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricmotortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricmotortypeenum): + self._predefinedtype = ifcelectricmotortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcelectricalbaseproperties # +#################### +class ifcelectricalbaseproperties(ifcenergyproperties): + '''Entity ifcelectricalbaseproperties definition. + + :param electriccurrenttype + :type electriccurrenttype:ifcelectriccurrentenum + + :param inputvoltage + :type inputvoltage:ifcelectricvoltagemeasure + + :param inputfrequency + :type inputfrequency:ifcfrequencymeasure + + :param fullloadcurrent + :type fullloadcurrent:ifcelectriccurrentmeasure + + :param minimumcircuitcurrent + :type minimumcircuitcurrent:ifcelectriccurrentmeasure + + :param maximumpowerinput + :type maximumpowerinput:ifcpowermeasure + + :param ratedpowerinput + :type ratedpowerinput:ifcpowermeasure + + :param inputphase + :type inputphase:INTEGER + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__energysequence , inherited5__userdefinedenergysequence , electriccurrenttype,inputvoltage,inputfrequency,fullloadcurrent,minimumcircuitcurrent,maximumpowerinput,ratedpowerinput,inputphase, ): + ifcenergyproperties.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__energysequence , inherited5__userdefinedenergysequence , ) + self.electriccurrenttype = electriccurrenttype + self.inputvoltage = inputvoltage + self.inputfrequency = inputfrequency + self.fullloadcurrent = fullloadcurrent + self.minimumcircuitcurrent = minimumcircuitcurrent + self.maximumpowerinput = maximumpowerinput + self.ratedpowerinput = ratedpowerinput + self.inputphase = inputphase + + @apply + def electriccurrenttype(): + def fget( self ): + return self._electriccurrenttype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelectriccurrentenum): + self._electriccurrenttype = ifcelectriccurrentenum(value) + else: + self._electriccurrenttype = value + else: + self._electriccurrenttype = value + return property(**locals()) + + @apply + def inputvoltage(): + def fget( self ): + return self._inputvoltage + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument inputvoltage is mantatory and can not be set to None') + if not check_type(value,ifcelectricvoltagemeasure): + self._inputvoltage = ifcelectricvoltagemeasure(value) + else: + self._inputvoltage = value + return property(**locals()) + + @apply + def inputfrequency(): + def fget( self ): + return self._inputfrequency + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument inputfrequency is mantatory and can not be set to None') + if not check_type(value,ifcfrequencymeasure): + self._inputfrequency = ifcfrequencymeasure(value) + else: + self._inputfrequency = value + return property(**locals()) + + @apply + def fullloadcurrent(): + def fget( self ): + return self._fullloadcurrent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelectriccurrentmeasure): + self._fullloadcurrent = ifcelectriccurrentmeasure(value) + else: + self._fullloadcurrent = value + else: + self._fullloadcurrent = value + return property(**locals()) + + @apply + def minimumcircuitcurrent(): + def fget( self ): + return self._minimumcircuitcurrent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelectriccurrentmeasure): + self._minimumcircuitcurrent = ifcelectriccurrentmeasure(value) + else: + self._minimumcircuitcurrent = value + else: + self._minimumcircuitcurrent = value + return property(**locals()) + + @apply + def maximumpowerinput(): + def fget( self ): + return self._maximumpowerinput + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpowermeasure): + self._maximumpowerinput = ifcpowermeasure(value) + else: + self._maximumpowerinput = value + else: + self._maximumpowerinput = value + return property(**locals()) + + @apply + def ratedpowerinput(): + def fget( self ): + return self._ratedpowerinput + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpowermeasure): + self._ratedpowerinput = ifcpowermeasure(value) + else: + self._ratedpowerinput = value + else: + self._ratedpowerinput = value + return property(**locals()) + + @apply + def inputphase(): + def fget( self ): + return self._inputphase + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument inputphase is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._inputphase = INTEGER(value) + else: + self._inputphase = value + return property(**locals()) + +#################### + # ENTITY ifcirregulartimeseriesvalue # +#################### +class ifcirregulartimeseriesvalue(BaseEntityClass): + '''Entity ifcirregulartimeseriesvalue definition. + + :param timestamp + :type timestamp:ifcdatetimeselect + + :param listvalues + :type listvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + ''' + def __init__( self , timestamp,listvalues, ): + self.timestamp = timestamp + self.listvalues = listvalues + + @apply + def timestamp(): + def fget( self ): + return self._timestamp + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timestamp is mantatory and can not be set to None') + if not check_type(value,ifcdatetimeselect): + self._timestamp = ifcdatetimeselect(value) + else: + self._timestamp = value + return property(**locals()) + + @apply + def listvalues(): + def fget( self ): + return self._listvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument listvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._listvalues = LIST(value) + else: + self._listvalues = value + return property(**locals()) + +#################### + # ENTITY ifcpresentationlayerassignment # +#################### +class ifcpresentationlayerassignment(BaseEntityClass): + '''Entity ifcpresentationlayerassignment definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param assigneditems + :type assigneditems:SET(1,None,'ifclayereditem', scope = schema_scope) + + :param identifier + :type identifier:ifcidentifier + ''' + def __init__( self , name,description,assigneditems,identifier, ): + self.name = name + self.description = description + self.assigneditems = assigneditems + self.identifier = identifier + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def assigneditems(): + def fget( self ): + return self._assigneditems + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigneditems is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifclayereditem', scope = schema_scope)): + self._assigneditems = SET(value) + else: + self._assigneditems = value + return property(**locals()) + + @apply + def identifier(): + def fget( self ): + return self._identifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identifier = ifcidentifier(value) + else: + self._identifier = value + else: + self._identifier = value + return property(**locals()) + +#################### + # ENTITY ifcprojectionelement # +#################### +class ifcprojectionelement(ifcfeatureelementaddition): + '''Entity ifcprojectionelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcfeatureelementaddition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcrelassociatesapproval # +#################### +class ifcrelassociatesapproval(ifcrelassociates): + '''Entity ifcrelassociatesapproval definition. + + :param relatingapproval + :type relatingapproval:ifcapproval + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingapproval, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingapproval = relatingapproval + + @apply + def relatingapproval(): + def fget( self ): + return self._relatingapproval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingapproval is mantatory and can not be set to None') + if not check_type(value,ifcapproval): + self._relatingapproval = ifcapproval(value) + else: + self._relatingapproval = value + return property(**locals()) + +#################### + # ENTITY ifccurvestyle # +#################### +class ifccurvestyle(ifcpresentationstyle): + '''Entity ifccurvestyle definition. + + :param curvefont + :type curvefont:ifccurvefontorscaledcurvefontselect + + :param curvewidth + :type curvewidth:ifcsizeselect + + :param curvecolour + :type curvecolour:ifccolour + ''' + def __init__( self , inherited0__name , curvefont,curvewidth,curvecolour, ): + ifcpresentationstyle.__init__(self , inherited0__name , ) + self.curvefont = curvefont + self.curvewidth = curvewidth + self.curvecolour = curvecolour + + @apply + def curvefont(): + def fget( self ): + return self._curvefont + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccurvefontorscaledcurvefontselect): + self._curvefont = ifccurvefontorscaledcurvefontselect(value) + else: + self._curvefont = value + else: + self._curvefont = value + return property(**locals()) + + @apply + def curvewidth(): + def fget( self ): + return self._curvewidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._curvewidth = ifcsizeselect(value) + else: + self._curvewidth = value + else: + self._curvewidth = value + return property(**locals()) + + @apply + def curvecolour(): + def fget( self ): + return self._curvecolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolour): + self._curvecolour = ifccolour(value) + else: + self._curvecolour = value + else: + self._curvecolour = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = ((( not EXISTS(self.curvewidth)) or ('IFC2X3.IFCPOSITIVELENGTHMEASURE' == TYPEOF(self.curvewidth))) or (('IFC2X3.IFCDESCRIPTIVEMEASURE' == TYPEOF(self.curvewidth)) and (self.curvewidth == 'by layer'))) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcdirection # +#################### +class ifcdirection(ifcgeometricrepresentationitem): + '''Entity ifcdirection definition. + + :param directionratios + :type directionratios:LIST(2,3,'REAL', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , directionratios, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.directionratios = directionratios + + @apply + def directionratios(): + def fget( self ): + return self._directionratios + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directionratios is mantatory and can not be set to None') + if not check_type(value,LIST(2,3,'REAL', scope = schema_scope)): + self._directionratios = LIST(value) + else: + self._directionratios = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = HIINDEX(self.directionratios) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcfillareastyletiles # +#################### +class ifcfillareastyletiles(ifcgeometricrepresentationitem): + '''Entity ifcfillareastyletiles definition. + + :param tilingpattern + :type tilingpattern:ifconedirectionrepeatfactor + + :param tiles + :type tiles:SET(1,None,'ifcfillareastyletileshapeselect', scope = schema_scope) + + :param tilingscale + :type tilingscale:ifcpositiveratiomeasure + ''' + def __init__( self , tilingpattern,tiles,tilingscale, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.tilingpattern = tilingpattern + self.tiles = tiles + self.tilingscale = tilingscale + + @apply + def tilingpattern(): + def fget( self ): + return self._tilingpattern + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tilingpattern is mantatory and can not be set to None') + if not check_type(value,ifconedirectionrepeatfactor): + self._tilingpattern = ifconedirectionrepeatfactor(value) + else: + self._tilingpattern = value + return property(**locals()) + + @apply + def tiles(): + def fget( self ): + return self._tiles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tiles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcfillareastyletileshapeselect', scope = schema_scope)): + self._tiles = SET(value) + else: + self._tiles = value + return property(**locals()) + + @apply + def tilingscale(): + def fget( self ): + return self._tilingscale + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tilingscale is mantatory and can not be set to None') + if not check_type(value,ifcpositiveratiomeasure): + self._tilingscale = ifcpositiveratiomeasure(value) + else: + self._tilingscale = value + return property(**locals()) + +#################### + # ENTITY ifcbeamtype # +#################### +class ifcbeamtype(ifcbuildingelementtype): + '''Entity ifcbeamtype definition. + + :param predefinedtype + :type predefinedtype:ifcbeamtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcbeamtypeenum): + self._predefinedtype = ifcbeamtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifclightsourcegoniometric # +#################### +class ifclightsourcegoniometric(ifclightsource): + '''Entity ifclightsourcegoniometric definition. + + :param position + :type position:ifcaxis2placement3d + + :param colourappearance + :type colourappearance:ifccolourrgb + + :param colourtemperature + :type colourtemperature:ifcthermodynamictemperaturemeasure + + :param luminousflux + :type luminousflux:ifcluminousfluxmeasure + + :param lightemissionsource + :type lightemissionsource:ifclightemissionsourceenum + + :param lightdistributiondatasource + :type lightdistributiondatasource:ifclightdistributiondatasourceselect + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , position,colourappearance,colourtemperature,luminousflux,lightemissionsource,lightdistributiondatasource, ): + ifclightsource.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ) + self.position = position + self.colourappearance = colourappearance + self.colourtemperature = colourtemperature + self.luminousflux = luminousflux + self.lightemissionsource = lightemissionsource + self.lightdistributiondatasource = lightdistributiondatasource + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def colourappearance(): + def fget( self ): + return self._colourappearance + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourrgb): + self._colourappearance = ifccolourrgb(value) + else: + self._colourappearance = value + else: + self._colourappearance = value + return property(**locals()) + + @apply + def colourtemperature(): + def fget( self ): + return self._colourtemperature + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colourtemperature is mantatory and can not be set to None') + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._colourtemperature = ifcthermodynamictemperaturemeasure(value) + else: + self._colourtemperature = value + return property(**locals()) + + @apply + def luminousflux(): + def fget( self ): + return self._luminousflux + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument luminousflux is mantatory and can not be set to None') + if not check_type(value,ifcluminousfluxmeasure): + self._luminousflux = ifcluminousfluxmeasure(value) + else: + self._luminousflux = value + return property(**locals()) + + @apply + def lightemissionsource(): + def fget( self ): + return self._lightemissionsource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lightemissionsource is mantatory and can not be set to None') + if not check_type(value,ifclightemissionsourceenum): + self._lightemissionsource = ifclightemissionsourceenum(value) + else: + self._lightemissionsource = value + return property(**locals()) + + @apply + def lightdistributiondatasource(): + def fget( self ): + return self._lightdistributiondatasource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lightdistributiondatasource is mantatory and can not be set to None') + if not check_type(value,ifclightdistributiondatasourceselect): + self._lightdistributiondatasource = ifclightdistributiondatasourceselect(value) + else: + self._lightdistributiondatasource = value + return property(**locals()) + +#################### + # ENTITY ifcsensortype # +#################### +class ifcsensortype(ifcdistributioncontrolelementtype): + '''Entity ifcsensortype definition. + + :param predefinedtype + :type predefinedtype:ifcsensortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcsensortypeenum): + self._predefinedtype = ifcsensortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralsteelprofileproperties # +#################### +class ifcstructuralsteelprofileproperties(ifcstructuralprofileproperties): + '''Entity ifcstructuralsteelprofileproperties definition. + + :param shearareaz + :type shearareaz:ifcareameasure + + :param shearareay + :type shearareay:ifcareameasure + + :param plasticshapefactory + :type plasticshapefactory:ifcpositiveratiomeasure + + :param plasticshapefactorz + :type plasticshapefactorz:ifcpositiveratiomeasure + ''' + def __init__( self , inherited0__profilename , inherited1__profiledefinition , inherited2__physicalweight , inherited3__perimeter , inherited4__minimumplatethickness , inherited5__maximumplatethickness , inherited6__crosssectionarea , inherited7__torsionalconstantx , inherited8__momentofinertiayz , inherited9__momentofinertiay , inherited10__momentofinertiaz , inherited11__warpingconstant , inherited12__shearcentrez , inherited13__shearcentrey , inherited14__sheardeformationareaz , inherited15__sheardeformationareay , inherited16__maximumsectionmodulusy , inherited17__minimumsectionmodulusy , inherited18__maximumsectionmodulusz , inherited19__minimumsectionmodulusz , inherited20__torsionalsectionmodulus , inherited21__centreofgravityinx , inherited22__centreofgravityiny , shearareaz,shearareay,plasticshapefactory,plasticshapefactorz, ): + ifcstructuralprofileproperties.__init__(self , inherited0__profilename , inherited1__profiledefinition , inherited2__physicalweight , inherited3__perimeter , inherited4__minimumplatethickness , inherited5__maximumplatethickness , inherited6__crosssectionarea , inherited7__torsionalconstantx , inherited8__momentofinertiayz , inherited9__momentofinertiay , inherited10__momentofinertiaz , inherited11__warpingconstant , inherited12__shearcentrez , inherited13__shearcentrey , inherited14__sheardeformationareaz , inherited15__sheardeformationareay , inherited16__maximumsectionmodulusy , inherited17__minimumsectionmodulusy , inherited18__maximumsectionmodulusz , inherited19__minimumsectionmodulusz , inherited20__torsionalsectionmodulus , inherited21__centreofgravityinx , inherited22__centreofgravityiny , ) + self.shearareaz = shearareaz + self.shearareay = shearareay + self.plasticshapefactory = plasticshapefactory + self.plasticshapefactorz = plasticshapefactorz + + @apply + def shearareaz(): + def fget( self ): + return self._shearareaz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._shearareaz = ifcareameasure(value) + else: + self._shearareaz = value + else: + self._shearareaz = value + return property(**locals()) + + @apply + def shearareay(): + def fget( self ): + return self._shearareay + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._shearareay = ifcareameasure(value) + else: + self._shearareay = value + else: + self._shearareay = value + return property(**locals()) + + @apply + def plasticshapefactory(): + def fget( self ): + return self._plasticshapefactory + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._plasticshapefactory = ifcpositiveratiomeasure(value) + else: + self._plasticshapefactory = value + else: + self._plasticshapefactory = value + return property(**locals()) + + @apply + def plasticshapefactorz(): + def fget( self ): + return self._plasticshapefactorz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._plasticshapefactorz = ifcpositiveratiomeasure(value) + else: + self._plasticshapefactorz = value + else: + self._plasticshapefactorz = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (( not EXISTS(self.shearareay)) or (self.shearareay >= 0)) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = (( not EXISTS(self.shearareaz)) or (self.shearareaz >= 0)) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + +#################### + # ENTITY ifcconnectionportgeometry # +#################### +class ifcconnectionportgeometry(ifcconnectiongeometry): + '''Entity ifcconnectionportgeometry definition. + + :param locationatrelatingelement + :type locationatrelatingelement:ifcaxis2placement + + :param locationatrelatedelement + :type locationatrelatedelement:ifcaxis2placement + + :param profileofport + :type profileofport:ifcprofiledef + ''' + def __init__( self , locationatrelatingelement,locationatrelatedelement,profileofport, ): + ifcconnectiongeometry.__init__(self , ) + self.locationatrelatingelement = locationatrelatingelement + self.locationatrelatedelement = locationatrelatedelement + self.profileofport = profileofport + + @apply + def locationatrelatingelement(): + def fget( self ): + return self._locationatrelatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument locationatrelatingelement is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._locationatrelatingelement = ifcaxis2placement(value) + else: + self._locationatrelatingelement = value + return property(**locals()) + + @apply + def locationatrelatedelement(): + def fget( self ): + return self._locationatrelatedelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaxis2placement): + self._locationatrelatedelement = ifcaxis2placement(value) + else: + self._locationatrelatedelement = value + else: + self._locationatrelatedelement = value + return property(**locals()) + + @apply + def profileofport(): + def fget( self ): + return self._profileofport + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument profileofport is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._profileofport = ifcprofiledef(value) + else: + self._profileofport = value + return property(**locals()) + +#################### + # ENTITY ifcwaterproperties # +#################### +class ifcwaterproperties(ifcmaterialproperties): + '''Entity ifcwaterproperties definition. + + :param ispotable + :type ispotable:BOOLEAN + + :param hardness + :type hardness:ifcionconcentrationmeasure + + :param alkalinityconcentration + :type alkalinityconcentration:ifcionconcentrationmeasure + + :param acidityconcentration + :type acidityconcentration:ifcionconcentrationmeasure + + :param impuritiescontent + :type impuritiescontent:ifcnormalisedratiomeasure + + :param phlevel + :type phlevel:ifcphmeasure + + :param dissolvedsolidscontent + :type dissolvedsolidscontent:ifcnormalisedratiomeasure + ''' + def __init__( self , inherited0__material , ispotable,hardness,alkalinityconcentration,acidityconcentration,impuritiescontent,phlevel,dissolvedsolidscontent, ): + ifcmaterialproperties.__init__(self , inherited0__material , ) + self.ispotable = ispotable + self.hardness = hardness + self.alkalinityconcentration = alkalinityconcentration + self.acidityconcentration = acidityconcentration + self.impuritiescontent = impuritiescontent + self.phlevel = phlevel + self.dissolvedsolidscontent = dissolvedsolidscontent + + @apply + def ispotable(): + def fget( self ): + return self._ispotable + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._ispotable = BOOLEAN(value) + else: + self._ispotable = value + else: + self._ispotable = value + return property(**locals()) + + @apply + def hardness(): + def fget( self ): + return self._hardness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcionconcentrationmeasure): + self._hardness = ifcionconcentrationmeasure(value) + else: + self._hardness = value + else: + self._hardness = value + return property(**locals()) + + @apply + def alkalinityconcentration(): + def fget( self ): + return self._alkalinityconcentration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcionconcentrationmeasure): + self._alkalinityconcentration = ifcionconcentrationmeasure(value) + else: + self._alkalinityconcentration = value + else: + self._alkalinityconcentration = value + return property(**locals()) + + @apply + def acidityconcentration(): + def fget( self ): + return self._acidityconcentration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcionconcentrationmeasure): + self._acidityconcentration = ifcionconcentrationmeasure(value) + else: + self._acidityconcentration = value + else: + self._acidityconcentration = value + return property(**locals()) + + @apply + def impuritiescontent(): + def fget( self ): + return self._impuritiescontent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._impuritiescontent = ifcnormalisedratiomeasure(value) + else: + self._impuritiescontent = value + else: + self._impuritiescontent = value + return property(**locals()) + + @apply + def phlevel(): + def fget( self ): + return self._phlevel + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcphmeasure): + self._phlevel = ifcphmeasure(value) + else: + self._phlevel = value + else: + self._phlevel = value + return property(**locals()) + + @apply + def dissolvedsolidscontent(): + def fget( self ): + return self._dissolvedsolidscontent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._dissolvedsolidscontent = ifcnormalisedratiomeasure(value) + else: + self._dissolvedsolidscontent = value + else: + self._dissolvedsolidscontent = value + return property(**locals()) + +#################### + # ENTITY ifcfuelproperties # +#################### +class ifcfuelproperties(ifcmaterialproperties): + '''Entity ifcfuelproperties definition. + + :param combustiontemperature + :type combustiontemperature:ifcthermodynamictemperaturemeasure + + :param carboncontent + :type carboncontent:ifcpositiveratiomeasure + + :param lowerheatingvalue + :type lowerheatingvalue:ifcheatingvaluemeasure + + :param higherheatingvalue + :type higherheatingvalue:ifcheatingvaluemeasure + ''' + def __init__( self , inherited0__material , combustiontemperature,carboncontent,lowerheatingvalue,higherheatingvalue, ): + ifcmaterialproperties.__init__(self , inherited0__material , ) + self.combustiontemperature = combustiontemperature + self.carboncontent = carboncontent + self.lowerheatingvalue = lowerheatingvalue + self.higherheatingvalue = higherheatingvalue + + @apply + def combustiontemperature(): + def fget( self ): + return self._combustiontemperature + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._combustiontemperature = ifcthermodynamictemperaturemeasure(value) + else: + self._combustiontemperature = value + else: + self._combustiontemperature = value + return property(**locals()) + + @apply + def carboncontent(): + def fget( self ): + return self._carboncontent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._carboncontent = ifcpositiveratiomeasure(value) + else: + self._carboncontent = value + else: + self._carboncontent = value + return property(**locals()) + + @apply + def lowerheatingvalue(): + def fget( self ): + return self._lowerheatingvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcheatingvaluemeasure): + self._lowerheatingvalue = ifcheatingvaluemeasure(value) + else: + self._lowerheatingvalue = value + else: + self._lowerheatingvalue = value + return property(**locals()) + + @apply + def higherheatingvalue(): + def fget( self ): + return self._higherheatingvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcheatingvaluemeasure): + self._higherheatingvalue = ifcheatingvaluemeasure(value) + else: + self._higherheatingvalue = value + else: + self._higherheatingvalue = value + return property(**locals()) + +#################### + # ENTITY ifclocaltime # +#################### +class ifclocaltime(BaseEntityClass): + '''Entity ifclocaltime definition. + + :param hourcomponent + :type hourcomponent:ifchourinday + + :param minutecomponent + :type minutecomponent:ifcminuteinhour + + :param secondcomponent + :type secondcomponent:ifcsecondinminute + + :param zone + :type zone:ifccoordinateduniversaltimeoffset + + :param daylightsavingoffset + :type daylightsavingoffset:ifcdaylightsavinghour + ''' + def __init__( self , hourcomponent,minutecomponent,secondcomponent,zone,daylightsavingoffset, ): + self.hourcomponent = hourcomponent + self.minutecomponent = minutecomponent + self.secondcomponent = secondcomponent + self.zone = zone + self.daylightsavingoffset = daylightsavingoffset + + @apply + def hourcomponent(): + def fget( self ): + return self._hourcomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hourcomponent is mantatory and can not be set to None') + if not check_type(value,ifchourinday): + self._hourcomponent = ifchourinday(value) + else: + self._hourcomponent = value + return property(**locals()) + + @apply + def minutecomponent(): + def fget( self ): + return self._minutecomponent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcminuteinhour): + self._minutecomponent = ifcminuteinhour(value) + else: + self._minutecomponent = value + else: + self._minutecomponent = value + return property(**locals()) + + @apply + def secondcomponent(): + def fget( self ): + return self._secondcomponent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsecondinminute): + self._secondcomponent = ifcsecondinminute(value) + else: + self._secondcomponent = value + else: + self._secondcomponent = value + return property(**locals()) + + @apply + def zone(): + def fget( self ): + return self._zone + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccoordinateduniversaltimeoffset): + self._zone = ifccoordinateduniversaltimeoffset(value) + else: + self._zone = value + else: + self._zone = value + return property(**locals()) + + @apply + def daylightsavingoffset(): + def fget( self ): + return self._daylightsavingoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdaylightsavinghour): + self._daylightsavingoffset = ifcdaylightsavinghour(value) + else: + self._daylightsavingoffset = value + else: + self._daylightsavingoffset = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ifcvalidtime(self) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcslippageconnectioncondition # +#################### +class ifcslippageconnectioncondition(ifcstructuralconnectioncondition): + '''Entity ifcslippageconnectioncondition definition. + + :param slippagex + :type slippagex:ifclengthmeasure + + :param slippagey + :type slippagey:ifclengthmeasure + + :param slippagez + :type slippagez:ifclengthmeasure + ''' + def __init__( self , inherited0__name , slippagex,slippagey,slippagez, ): + ifcstructuralconnectioncondition.__init__(self , inherited0__name , ) + self.slippagex = slippagex + self.slippagey = slippagey + self.slippagez = slippagez + + @apply + def slippagex(): + def fget( self ): + return self._slippagex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._slippagex = ifclengthmeasure(value) + else: + self._slippagex = value + else: + self._slippagex = value + return property(**locals()) + + @apply + def slippagey(): + def fget( self ): + return self._slippagey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._slippagey = ifclengthmeasure(value) + else: + self._slippagey = value + else: + self._slippagey = value + return property(**locals()) + + @apply + def slippagez(): + def fget( self ): + return self._slippagez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._slippagez = ifclengthmeasure(value) + else: + self._slippagez = value + else: + self._slippagez = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralresultgroup # +#################### +class ifcstructuralresultgroup(ifcgroup): + '''Entity ifcstructuralresultgroup definition. + + :param theorytype + :type theorytype:ifcanalysistheorytypeenum + + :param resultforloadgroup + :type resultforloadgroup:ifcstructuralloadgroup + + :param islinear + :type islinear:BOOLEAN + + :param resultgroupfor + :type resultgroupfor:SET(0,1,'ifcstructuralanalysismodel', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , theorytype,resultforloadgroup,islinear, ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.theorytype = theorytype + self.resultforloadgroup = resultforloadgroup + self.islinear = islinear + + @apply + def theorytype(): + def fget( self ): + return self._theorytype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument theorytype is mantatory and can not be set to None') + if not check_type(value,ifcanalysistheorytypeenum): + self._theorytype = ifcanalysistheorytypeenum(value) + else: + self._theorytype = value + return property(**locals()) + + @apply + def resultforloadgroup(): + def fget( self ): + return self._resultforloadgroup + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstructuralloadgroup): + self._resultforloadgroup = ifcstructuralloadgroup(value) + else: + self._resultforloadgroup = value + else: + self._resultforloadgroup = value + return property(**locals()) + + @apply + def islinear(): + def fget( self ): + return self._islinear + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument islinear is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._islinear = BOOLEAN(value) + else: + self._islinear = value + return property(**locals()) + + @apply + def resultgroupfor(): + def fget( self ): + return self._resultgroupfor + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument resultgroupfor is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifctopologyrepresentation # +#################### +class ifctopologyrepresentation(ifcshapemodel): + '''Entity ifctopologyrepresentation definition. + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcshapemodel.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = EXISTS(self.self.ifcrepresentation.self.representationtype) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + def wr23(self): + eval_wr23_wr = ifctopologyrepresentationtypes(self.self.ifcrepresentation.self.representationtype,self.self.ifcrepresentation.self.items) + if not eval_wr23_wr: + raise AssertionError('Rule wr23 violated') + else: + return eval_wr23_wr + + +#################### + # ENTITY ifcblock # +#################### +class ifcblock(ifccsgprimitive3d): + '''Entity ifcblock definition. + + :param xlength + :type xlength:ifcpositivelengthmeasure + + :param ylength + :type ylength:ifcpositivelengthmeasure + + :param zlength + :type zlength:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , xlength,ylength,zlength, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.xlength = xlength + self.ylength = ylength + self.zlength = zlength + + @apply + def xlength(): + def fget( self ): + return self._xlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument xlength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._xlength = ifcpositivelengthmeasure(value) + else: + self._xlength = value + return property(**locals()) + + @apply + def ylength(): + def fget( self ): + return self._ylength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ylength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ylength = ifcpositivelengthmeasure(value) + else: + self._ylength = value + return property(**locals()) + + @apply + def zlength(): + def fget( self ): + return self._zlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument zlength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._zlength = ifcpositivelengthmeasure(value) + else: + self._zlength = value + return property(**locals()) + +#################### + # ENTITY ifcconnectionpointgeometry # +#################### +class ifcconnectionpointgeometry(ifcconnectiongeometry): + '''Entity ifcconnectionpointgeometry definition. + + :param pointonrelatingelement + :type pointonrelatingelement:ifcpointorvertexpoint + + :param pointonrelatedelement + :type pointonrelatedelement:ifcpointorvertexpoint + ''' + def __init__( self , pointonrelatingelement,pointonrelatedelement, ): + ifcconnectiongeometry.__init__(self , ) + self.pointonrelatingelement = pointonrelatingelement + self.pointonrelatedelement = pointonrelatedelement + + @apply + def pointonrelatingelement(): + def fget( self ): + return self._pointonrelatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pointonrelatingelement is mantatory and can not be set to None') + if not check_type(value,ifcpointorvertexpoint): + self._pointonrelatingelement = ifcpointorvertexpoint(value) + else: + self._pointonrelatingelement = value + return property(**locals()) + + @apply + def pointonrelatedelement(): + def fget( self ): + return self._pointonrelatedelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpointorvertexpoint): + self._pointonrelatedelement = ifcpointorvertexpoint(value) + else: + self._pointonrelatedelement = value + else: + self._pointonrelatedelement = value + return property(**locals()) + +#################### + # ENTITY ifcconnectionpointeccentricity # +#################### +class ifcconnectionpointeccentricity(ifcconnectionpointgeometry): + '''Entity ifcconnectionpointeccentricity definition. + + :param eccentricityinx + :type eccentricityinx:ifclengthmeasure + + :param eccentricityiny + :type eccentricityiny:ifclengthmeasure + + :param eccentricityinz + :type eccentricityinz:ifclengthmeasure + ''' + def __init__( self , inherited0__pointonrelatingelement , inherited1__pointonrelatedelement , eccentricityinx,eccentricityiny,eccentricityinz, ): + ifcconnectionpointgeometry.__init__(self , inherited0__pointonrelatingelement , inherited1__pointonrelatedelement , ) + self.eccentricityinx = eccentricityinx + self.eccentricityiny = eccentricityiny + self.eccentricityinz = eccentricityinz + + @apply + def eccentricityinx(): + def fget( self ): + return self._eccentricityinx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._eccentricityinx = ifclengthmeasure(value) + else: + self._eccentricityinx = value + else: + self._eccentricityinx = value + return property(**locals()) + + @apply + def eccentricityiny(): + def fget( self ): + return self._eccentricityiny + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._eccentricityiny = ifclengthmeasure(value) + else: + self._eccentricityiny = value + else: + self._eccentricityiny = value + return property(**locals()) + + @apply + def eccentricityinz(): + def fget( self ): + return self._eccentricityinz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._eccentricityinz = ifclengthmeasure(value) + else: + self._eccentricityinz = value + else: + self._eccentricityinz = value + return property(**locals()) + +#################### + # ENTITY ifcedgeloop # +#################### +class ifcedgeloop(ifcloop): + '''Entity ifcedgeloop definition. + + :param edgelist + :type edgelist:LIST(1,None,'ifcorientededge', scope = schema_scope) + + :param ne + :type ne:INTEGER + ''' + def __init__( self , edgelist, ): + ifcloop.__init__(self , ) + self.edgelist = edgelist + + @apply + def edgelist(): + def fget( self ): + return self._edgelist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgelist is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcorientededge', scope = schema_scope)): + self._edgelist = LIST(value) + else: + self._edgelist = value + return property(**locals()) + + @apply + def ne(): + def fget( self ): + attribute_eval = SIZEOF(self.edgelist) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ne is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.edgelist[1].self.edgestart == self.edgelist[self.ne].self.edgeend) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ifcloopheadtotail(self) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcrelservicesbuildings # +#################### +class ifcrelservicesbuildings(ifcrelconnects): + '''Entity ifcrelservicesbuildings definition. + + :param relatingsystem + :type relatingsystem:ifcsystem + + :param relatedbuildings + :type relatedbuildings:SET(1,None,'ifcspatialstructureelement', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingsystem,relatedbuildings, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingsystem = relatingsystem + self.relatedbuildings = relatedbuildings + + @apply + def relatingsystem(): + def fget( self ): + return self._relatingsystem + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingsystem is mantatory and can not be set to None') + if not check_type(value,ifcsystem): + self._relatingsystem = ifcsystem(value) + else: + self._relatingsystem = value + return property(**locals()) + + @apply + def relatedbuildings(): + def fget( self ): + return self._relatedbuildings + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedbuildings is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcspatialstructureelement', scope = schema_scope)): + self._relatedbuildings = SET(value) + else: + self._relatedbuildings = value + return property(**locals()) + +#################### + # ENTITY ifctexturecoordinategenerator # +#################### +class ifctexturecoordinategenerator(ifctexturecoordinate): + '''Entity ifctexturecoordinategenerator definition. + + :param mode + :type mode:ifclabel + + :param parameter + :type parameter:LIST(1,None,'ifcsimplevalue', scope = schema_scope) + ''' + def __init__( self , mode,parameter, ): + ifctexturecoordinate.__init__(self , ) + self.mode = mode + self.parameter = parameter + + @apply + def mode(): + def fget( self ): + return self._mode + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mode is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._mode = ifclabel(value) + else: + self._mode = value + return property(**locals()) + + @apply + def parameter(): + def fget( self ): + return self._parameter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parameter is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcsimplevalue', scope = schema_scope)): + self._parameter = LIST(value) + else: + self._parameter = value + return property(**locals()) + +#################### + # ENTITY ifccablecarrierfittingtype # +#################### +class ifccablecarrierfittingtype(ifcflowfittingtype): + '''Entity ifccablecarrierfittingtype definition. + + :param predefinedtype + :type predefinedtype:ifccablecarrierfittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowfittingtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccablecarrierfittingtypeenum): + self._predefinedtype = ifccablecarrierfittingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifccablecarrierfittingtypeenum.self.userdefined) or ((self.predefinedtype == ifccablecarrierfittingtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcappliedvaluerelationship # +#################### +class ifcappliedvaluerelationship(BaseEntityClass): + '''Entity ifcappliedvaluerelationship definition. + + :param componentoftotal + :type componentoftotal:ifcappliedvalue + + :param components + :type components:SET(1,None,'ifcappliedvalue', scope = schema_scope) + + :param arithmeticoperator + :type arithmeticoperator:ifcarithmeticoperatorenum + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + ''' + def __init__( self , componentoftotal,components,arithmeticoperator,name,description, ): + self.componentoftotal = componentoftotal + self.components = components + self.arithmeticoperator = arithmeticoperator + self.name = name + self.description = description + + @apply + def componentoftotal(): + def fget( self ): + return self._componentoftotal + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument componentoftotal is mantatory and can not be set to None') + if not check_type(value,ifcappliedvalue): + self._componentoftotal = ifcappliedvalue(value) + else: + self._componentoftotal = value + return property(**locals()) + + @apply + def components(): + def fget( self ): + return self._components + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument components is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcappliedvalue', scope = schema_scope)): + self._components = SET(value) + else: + self._components = value + return property(**locals()) + + @apply + def arithmeticoperator(): + def fget( self ): + return self._arithmeticoperator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument arithmeticoperator is mantatory and can not be set to None') + if not check_type(value,ifcarithmeticoperatorenum): + self._arithmeticoperator = ifcarithmeticoperatorenum(value) + else: + self._arithmeticoperator = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY ifcclassificationnotationfacet # +#################### +class ifcclassificationnotationfacet(BaseEntityClass): + '''Entity ifcclassificationnotationfacet definition. + + :param notationvalue + :type notationvalue:ifclabel + ''' + def __init__( self , notationvalue, ): + self.notationvalue = notationvalue + + @apply + def notationvalue(): + def fget( self ): + return self._notationvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument notationvalue is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._notationvalue = ifclabel(value) + else: + self._notationvalue = value + return property(**locals()) + +#################### + # ENTITY ifcdimensioncurveterminator # +#################### +class ifcdimensioncurveterminator(ifcterminatorsymbol): + '''Entity ifcdimensioncurveterminator definition. + + :param role + :type role:ifcdimensionextentusage + ''' + def __init__( self , inherited0__item , inherited1__styles , inherited2__name , inherited3__annotatedcurve , role, ): + ifcterminatorsymbol.__init__(self , inherited0__item , inherited1__styles , inherited2__name , inherited3__annotatedcurve , ) + self.role = role + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,ifcdimensionextentusage): + self._role = ifcdimensionextentusage(value) + else: + self._role = value + return property(**locals()) + def wr61(self): + eval_wr61_wr = ('IFC2X3.IFCDIMENSIONCURVE' == TYPEOF(self.self.ifcterminatorsymbol.self.annotatedcurve)) + if not eval_wr61_wr: + raise AssertionError('Rule wr61 violated') + else: + return eval_wr61_wr + + +#################### + # ENTITY ifcductfittingtype # +#################### +class ifcductfittingtype(ifcflowfittingtype): + '''Entity ifcductfittingtype definition. + + :param predefinedtype + :type predefinedtype:ifcductfittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowfittingtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcductfittingtypeenum): + self._predefinedtype = ifcductfittingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr2(self): + eval_wr2_wr = ((self.predefinedtype != ifcductfittingtypeenum.self.userdefined) or ((self.predefinedtype == ifcductfittingtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifclocalplacement # +#################### +class ifclocalplacement(ifcobjectplacement): + '''Entity ifclocalplacement definition. + + :param placementrelto + :type placementrelto:ifcobjectplacement + + :param relativeplacement + :type relativeplacement:ifcaxis2placement + ''' + def __init__( self , placementrelto,relativeplacement, ): + ifcobjectplacement.__init__(self , ) + self.placementrelto = placementrelto + self.relativeplacement = relativeplacement + + @apply + def placementrelto(): + def fget( self ): + return self._placementrelto + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcobjectplacement): + self._placementrelto = ifcobjectplacement(value) + else: + self._placementrelto = value + else: + self._placementrelto = value + return property(**locals()) + + @apply + def relativeplacement(): + def fget( self ): + return self._relativeplacement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relativeplacement is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._relativeplacement = ifcaxis2placement(value) + else: + self._relativeplacement = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ifccorrectlocalplacement(self.relativeplacement,self.placementrelto) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcpropertyset # +#################### +class ifcpropertyset(ifcpropertysetdefinition): + '''Entity ifcpropertyset definition. + + :param hasproperties + :type hasproperties:SET(1,None,'ifcproperty', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , hasproperties, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.hasproperties = hasproperties + + @apply + def hasproperties(): + def fget( self ): + return self._hasproperties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hasproperties is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproperty', scope = schema_scope)): + self._hasproperties = SET(value) + else: + self._hasproperties = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = ifcuniquepropertyname(self.hasproperties) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + +#################### + # ENTITY ifcstructuralcurvemembervarying # +#################### +class ifcstructuralcurvemembervarying(ifcstructuralcurvemember): + '''Entity ifcstructuralcurvemembervarying definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__predefinedtype , ): + ifcstructuralcurvemember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__predefinedtype , ) + +#################### + # ENTITY ifcunitaryequipmenttype # +#################### +class ifcunitaryequipmenttype(ifcenergyconversiondevicetype): + '''Entity ifcunitaryequipmenttype definition. + + :param predefinedtype + :type predefinedtype:ifcunitaryequipmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcunitaryequipmenttypeenum): + self._predefinedtype = ifcunitaryequipmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcunitaryequipmenttypeenum.self.userdefined) or ((self.predefinedtype == ifcunitaryequipmenttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifczone # +#################### +class ifczone(ifcgroup): + '''Entity ifczone definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelprojectselement # +#################### +class ifcrelprojectselement(ifcrelconnects): + '''Entity ifcrelprojectselement definition. + + :param relatingelement + :type relatingelement:ifcelement + + :param relatedfeatureelement + :type relatedfeatureelement:ifcfeatureelementaddition + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingelement,relatedfeatureelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingelement = relatingelement + self.relatedfeatureelement = relatedfeatureelement + + @apply + def relatingelement(): + def fget( self ): + return self._relatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingelement = ifcelement(value) + else: + self._relatingelement = value + return property(**locals()) + + @apply + def relatedfeatureelement(): + def fget( self ): + return self._relatedfeatureelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedfeatureelement is mantatory and can not be set to None') + if not check_type(value,ifcfeatureelementaddition): + self._relatedfeatureelement = ifcfeatureelementaddition(value) + else: + self._relatedfeatureelement = value + return property(**locals()) + +#################### + # ENTITY ifctanktype # +#################### +class ifctanktype(ifcflowstoragedevicetype): + '''Entity ifctanktype definition. + + :param predefinedtype + :type predefinedtype:ifctanktypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowstoragedevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctanktypeenum): + self._predefinedtype = ifctanktypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifctanktypeenum.self.userdefined) or ((self.predefinedtype == ifctanktypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcdocumentelectronicformat # +#################### +class ifcdocumentelectronicformat(BaseEntityClass): + '''Entity ifcdocumentelectronicformat definition. + + :param fileextension + :type fileextension:ifclabel + + :param mimecontenttype + :type mimecontenttype:ifclabel + + :param mimesubtype + :type mimesubtype:ifclabel + ''' + def __init__( self , fileextension,mimecontenttype,mimesubtype, ): + self.fileextension = fileextension + self.mimecontenttype = mimecontenttype + self.mimesubtype = mimesubtype + + @apply + def fileextension(): + def fget( self ): + return self._fileextension + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._fileextension = ifclabel(value) + else: + self._fileextension = value + else: + self._fileextension = value + return property(**locals()) + + @apply + def mimecontenttype(): + def fget( self ): + return self._mimecontenttype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._mimecontenttype = ifclabel(value) + else: + self._mimecontenttype = value + else: + self._mimecontenttype = value + return property(**locals()) + + @apply + def mimesubtype(): + def fget( self ): + return self._mimesubtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._mimesubtype = ifclabel(value) + else: + self._mimesubtype = value + else: + self._mimesubtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (EXISTS(self.fileextension) or EXISTS(self.mimecontenttype)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcwindowstyle # +#################### +class ifcwindowstyle(ifctypeproduct): + '''Entity ifcwindowstyle definition. + + :param constructiontype + :type constructiontype:ifcwindowstyleconstructionenum + + :param operationtype + :type operationtype:ifcwindowstyleoperationenum + + :param parametertakesprecedence + :type parametertakesprecedence:BOOLEAN + + :param sizeable + :type sizeable:BOOLEAN + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , constructiontype,operationtype,parametertakesprecedence,sizeable, ): + ifctypeproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , ) + self.constructiontype = constructiontype + self.operationtype = operationtype + self.parametertakesprecedence = parametertakesprecedence + self.sizeable = sizeable + + @apply + def constructiontype(): + def fget( self ): + return self._constructiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constructiontype is mantatory and can not be set to None') + if not check_type(value,ifcwindowstyleconstructionenum): + self._constructiontype = ifcwindowstyleconstructionenum(value) + else: + self._constructiontype = value + return property(**locals()) + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operationtype is mantatory and can not be set to None') + if not check_type(value,ifcwindowstyleoperationenum): + self._operationtype = ifcwindowstyleoperationenum(value) + else: + self._operationtype = value + return property(**locals()) + + @apply + def parametertakesprecedence(): + def fget( self ): + return self._parametertakesprecedence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parametertakesprecedence is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._parametertakesprecedence = BOOLEAN(value) + else: + self._parametertakesprecedence = value + return property(**locals()) + + @apply + def sizeable(): + def fget( self ): + return self._sizeable + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sizeable is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._sizeable = BOOLEAN(value) + else: + self._sizeable = value + return property(**locals()) + +#################### + # ENTITY ifcworkschedule # +#################### +class ifcworkschedule(ifcworkcontrol): + '''Entity ifcworkschedule definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identifier , inherited6__creationdate , inherited7__creators , inherited8__purpose , inherited9__duration , inherited10__totalfloat , inherited11__starttime , inherited12__finishtime , inherited13__workcontroltype , inherited14__userdefinedcontroltype , ): + ifcworkcontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identifier , inherited6__creationdate , inherited7__creators , inherited8__purpose , inherited9__duration , inherited10__totalfloat , inherited11__starttime , inherited12__finishtime , inherited13__workcontroltype , inherited14__userdefinedcontroltype , ) + +#################### + # ENTITY ifcboundaryfacecondition # +#################### +class ifcboundaryfacecondition(ifcboundarycondition): + '''Entity ifcboundaryfacecondition definition. + + :param linearstiffnessbyareax + :type linearstiffnessbyareax:ifcmodulusofsubgradereactionmeasure + + :param linearstiffnessbyareay + :type linearstiffnessbyareay:ifcmodulusofsubgradereactionmeasure + + :param linearstiffnessbyareaz + :type linearstiffnessbyareaz:ifcmodulusofsubgradereactionmeasure + ''' + def __init__( self , inherited0__name , linearstiffnessbyareax,linearstiffnessbyareay,linearstiffnessbyareaz, ): + ifcboundarycondition.__init__(self , inherited0__name , ) + self.linearstiffnessbyareax = linearstiffnessbyareax + self.linearstiffnessbyareay = linearstiffnessbyareay + self.linearstiffnessbyareaz = linearstiffnessbyareaz + + @apply + def linearstiffnessbyareax(): + def fget( self ): + return self._linearstiffnessbyareax + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofsubgradereactionmeasure): + self._linearstiffnessbyareax = ifcmodulusofsubgradereactionmeasure(value) + else: + self._linearstiffnessbyareax = value + else: + self._linearstiffnessbyareax = value + return property(**locals()) + + @apply + def linearstiffnessbyareay(): + def fget( self ): + return self._linearstiffnessbyareay + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofsubgradereactionmeasure): + self._linearstiffnessbyareay = ifcmodulusofsubgradereactionmeasure(value) + else: + self._linearstiffnessbyareay = value + else: + self._linearstiffnessbyareay = value + return property(**locals()) + + @apply + def linearstiffnessbyareaz(): + def fget( self ): + return self._linearstiffnessbyareaz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofsubgradereactionmeasure): + self._linearstiffnessbyareaz = ifcmodulusofsubgradereactionmeasure(value) + else: + self._linearstiffnessbyareaz = value + else: + self._linearstiffnessbyareaz = value + return property(**locals()) + +#################### + # ENTITY ifccompositeprofiledef # +#################### +class ifccompositeprofiledef(ifcprofiledef): + '''Entity ifccompositeprofiledef definition. + + :param profiles + :type profiles:SET(2,None,'ifcprofiledef', scope = schema_scope) + + :param label + :type label:ifclabel + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , profiles,label, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.profiles = profiles + self.label = label + + @apply + def profiles(): + def fget( self ): + return self._profiles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument profiles is mantatory and can not be set to None') + if not check_type(value,SET(2,None,'ifcprofiledef', scope = schema_scope)): + self._profiles = SET(value) + else: + self._profiles = value + return property(**locals()) + + @apply + def label(): + def fget( self ): + return self._label + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._label = ifclabel(value) + else: + self._label = value + else: + self._label = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcasset # +#################### +class ifcasset(ifcgroup): + '''Entity ifcasset definition. + + :param assetid + :type assetid:ifcidentifier + + :param originalvalue + :type originalvalue:ifccostvalue + + :param currentvalue + :type currentvalue:ifccostvalue + + :param totalreplacementcost + :type totalreplacementcost:ifccostvalue + + :param owner + :type owner:ifcactorselect + + :param user + :type user:ifcactorselect + + :param responsibleperson + :type responsibleperson:ifcperson + + :param incorporationdate + :type incorporationdate:ifccalendardate + + :param depreciatedvalue + :type depreciatedvalue:ifccostvalue + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , assetid,originalvalue,currentvalue,totalreplacementcost,owner,user,responsibleperson,incorporationdate,depreciatedvalue, ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.assetid = assetid + self.originalvalue = originalvalue + self.currentvalue = currentvalue + self.totalreplacementcost = totalreplacementcost + self.owner = owner + self.user = user + self.responsibleperson = responsibleperson + self.incorporationdate = incorporationdate + self.depreciatedvalue = depreciatedvalue + + @apply + def assetid(): + def fget( self ): + return self._assetid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assetid is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._assetid = ifcidentifier(value) + else: + self._assetid = value + return property(**locals()) + + @apply + def originalvalue(): + def fget( self ): + return self._originalvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument originalvalue is mantatory and can not be set to None') + if not check_type(value,ifccostvalue): + self._originalvalue = ifccostvalue(value) + else: + self._originalvalue = value + return property(**locals()) + + @apply + def currentvalue(): + def fget( self ): + return self._currentvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument currentvalue is mantatory and can not be set to None') + if not check_type(value,ifccostvalue): + self._currentvalue = ifccostvalue(value) + else: + self._currentvalue = value + return property(**locals()) + + @apply + def totalreplacementcost(): + def fget( self ): + return self._totalreplacementcost + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument totalreplacementcost is mantatory and can not be set to None') + if not check_type(value,ifccostvalue): + self._totalreplacementcost = ifccostvalue(value) + else: + self._totalreplacementcost = value + return property(**locals()) + + @apply + def owner(): + def fget( self ): + return self._owner + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument owner is mantatory and can not be set to None') + if not check_type(value,ifcactorselect): + self._owner = ifcactorselect(value) + else: + self._owner = value + return property(**locals()) + + @apply + def user(): + def fget( self ): + return self._user + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument user is mantatory and can not be set to None') + if not check_type(value,ifcactorselect): + self._user = ifcactorselect(value) + else: + self._user = value + return property(**locals()) + + @apply + def responsibleperson(): + def fget( self ): + return self._responsibleperson + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument responsibleperson is mantatory and can not be set to None') + if not check_type(value,ifcperson): + self._responsibleperson = ifcperson(value) + else: + self._responsibleperson = value + return property(**locals()) + + @apply + def incorporationdate(): + def fget( self ): + return self._incorporationdate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument incorporationdate is mantatory and can not be set to None') + if not check_type(value,ifccalendardate): + self._incorporationdate = ifccalendardate(value) + else: + self._incorporationdate = value + return property(**locals()) + + @apply + def depreciatedvalue(): + def fget( self ): + return self._depreciatedvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depreciatedvalue is mantatory and can not be set to None') + if not check_type(value,ifccostvalue): + self._depreciatedvalue = ifccostvalue(value) + else: + self._depreciatedvalue = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcirregulartimeseries # +#################### +class ifcirregulartimeseries(ifctimeseries): + '''Entity ifcirregulartimeseries definition. + + :param values + :type values:LIST(1,None,'ifcirregulartimeseriesvalue', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__starttime , inherited3__endtime , inherited4__timeseriesdatatype , inherited5__dataorigin , inherited6__userdefineddataorigin , inherited7__unit , values, ): + ifctimeseries.__init__(self , inherited0__name , inherited1__description , inherited2__starttime , inherited3__endtime , inherited4__timeseriesdatatype , inherited5__dataorigin , inherited6__userdefineddataorigin , inherited7__unit , ) + self.values = values + + @apply + def values(): + def fget( self ): + return self._values + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument values is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcirregulartimeseriesvalue', scope = schema_scope)): + self._values = LIST(value) + else: + self._values = value + return property(**locals()) + +#################### + # ENTITY ifcblobtexture # +#################### +class ifcblobtexture(ifcsurfacetexture): + '''Entity ifcblobtexture definition. + + :param rasterformat + :type rasterformat:ifcidentifier + + :param rastercode + :type rastercode:BOOLEAN + ''' + def __init__( self , inherited0__repeats , inherited1__repeatt , inherited2__texturetype , inherited3__texturetransform , rasterformat,rastercode, ): + ifcsurfacetexture.__init__(self , inherited0__repeats , inherited1__repeatt , inherited2__texturetype , inherited3__texturetransform , ) + self.rasterformat = rasterformat + self.rastercode = rastercode + + @apply + def rasterformat(): + def fget( self ): + return self._rasterformat + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rasterformat is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._rasterformat = ifcidentifier(value) + else: + self._rasterformat = value + return property(**locals()) + + @apply + def rastercode(): + def fget( self ): + return self._rastercode + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rastercode is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._rastercode = BOOLEAN(value) + else: + self._rastercode = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (self.self.rasterformat == ['BMP','JPG','GIF','PNG']) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifclightintensitydistribution # +#################### +class ifclightintensitydistribution(BaseEntityClass): + '''Entity ifclightintensitydistribution definition. + + :param lightdistributioncurve + :type lightdistributioncurve:ifclightdistributioncurveenum + + :param distributiondata + :type distributiondata:LIST(1,None,'ifclightdistributiondata', scope = schema_scope) + ''' + def __init__( self , lightdistributioncurve,distributiondata, ): + self.lightdistributioncurve = lightdistributioncurve + self.distributiondata = distributiondata + + @apply + def lightdistributioncurve(): + def fget( self ): + return self._lightdistributioncurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lightdistributioncurve is mantatory and can not be set to None') + if not check_type(value,ifclightdistributioncurveenum): + self._lightdistributioncurve = ifclightdistributioncurveenum(value) + else: + self._lightdistributioncurve = value + return property(**locals()) + + @apply + def distributiondata(): + def fget( self ): + return self._distributiondata + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distributiondata is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifclightdistributiondata', scope = schema_scope)): + self._distributiondata = LIST(value) + else: + self._distributiondata = value + return property(**locals()) + +#################### + # ENTITY ifcorderaction # +#################### +class ifcorderaction(ifctask): + '''Entity ifcorderaction definition. + + :param actionid + :type actionid:ifcidentifier + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__taskid , inherited6__status , inherited7__workmethod , inherited8__ismilestone , inherited9__priority , actionid, ): + ifctask.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__taskid , inherited6__status , inherited7__workmethod , inherited8__ismilestone , inherited9__priority , ) + self.actionid = actionid + + @apply + def actionid(): + def fget( self ): + return self._actionid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actionid is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._actionid = ifcidentifier(value) + else: + self._actionid = value + return property(**locals()) + +#################### + # ENTITY ifcgrid # +#################### +class ifcgrid(ifcproduct): + '''Entity ifcgrid definition. + + :param uaxes + :type uaxes:LIST(1,None,'ifcgridaxis', scope = schema_scope) + + :param vaxes + :type vaxes:LIST(1,None,'ifcgridaxis', scope = schema_scope) + + :param waxes + :type waxes:LIST(1,None,'ifcgridaxis', scope = schema_scope) + + :param containedinstructure + :type containedinstructure:SET(0,1,'ifcrelcontainedinspatialstructure', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , uaxes,vaxes,waxes, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.uaxes = uaxes + self.vaxes = vaxes + self.waxes = waxes + + @apply + def uaxes(): + def fget( self ): + return self._uaxes + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument uaxes is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcgridaxis', scope = schema_scope)): + self._uaxes = LIST(value) + else: + self._uaxes = value + return property(**locals()) + + @apply + def vaxes(): + def fget( self ): + return self._vaxes + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vaxes is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcgridaxis', scope = schema_scope)): + self._vaxes = LIST(value) + else: + self._vaxes = value + return property(**locals()) + + @apply + def waxes(): + def fget( self ): + return self._waxes + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcgridaxis', scope = schema_scope)): + self._waxes = LIST(value) + else: + self._waxes = value + else: + self._waxes = value + return property(**locals()) + + @apply + def containedinstructure(): + def fget( self ): + return self._containedinstructure + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containedinstructure is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr41(self): + eval_wr41_wr = EXISTS(self.self.ifcproduct.self.objectplacement) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + +#################### + # ENTITY ifcmechanicalfastener # +#################### +class ifcmechanicalfastener(ifcfastener): + '''Entity ifcmechanicalfastener definition. + + :param nominaldiameter + :type nominaldiameter:ifcpositivelengthmeasure + + :param nominallength + :type nominallength:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , nominaldiameter,nominallength, ): + ifcfastener.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.nominaldiameter = nominaldiameter + self.nominallength = nominallength + + @apply + def nominaldiameter(): + def fget( self ): + return self._nominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominaldiameter = ifcpositivelengthmeasure(value) + else: + self._nominaldiameter = value + else: + self._nominaldiameter = value + return property(**locals()) + + @apply + def nominallength(): + def fget( self ): + return self._nominallength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominallength = ifcpositivelengthmeasure(value) + else: + self._nominallength = value + else: + self._nominallength = value + return property(**locals()) + +#################### + # ENTITY ifcphysicalcomplexquantity # +#################### +class ifcphysicalcomplexquantity(ifcphysicalquantity): + '''Entity ifcphysicalcomplexquantity definition. + + :param hasquantities + :type hasquantities:SET(1,None,'ifcphysicalquantity', scope = schema_scope) + + :param discrimination + :type discrimination:ifclabel + + :param quality + :type quality:ifclabel + + :param usage + :type usage:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , hasquantities,discrimination,quality,usage, ): + ifcphysicalquantity.__init__(self , inherited0__name , inherited1__description , ) + self.hasquantities = hasquantities + self.discrimination = discrimination + self.quality = quality + self.usage = usage + + @apply + def hasquantities(): + def fget( self ): + return self._hasquantities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hasquantities is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcphysicalquantity', scope = schema_scope)): + self._hasquantities = SET(value) + else: + self._hasquantities = value + return property(**locals()) + + @apply + def discrimination(): + def fget( self ): + return self._discrimination + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument discrimination is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._discrimination = ifclabel(value) + else: + self._discrimination = value + return property(**locals()) + + @apply + def quality(): + def fget( self ): + return self._quality + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._quality = ifclabel(value) + else: + self._quality = value + else: + self._quality = value + return property(**locals()) + + @apply + def usage(): + def fget( self ): + return self._usage + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._usage = ifclabel(value) + else: + self._usage = value + else: + self._usage = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcpresentationlayerwithstyle # +#################### +class ifcpresentationlayerwithstyle(ifcpresentationlayerassignment): + '''Entity ifcpresentationlayerwithstyle definition. + + :param layeron + :type layeron:LOGICAL + + :param layerfrozen + :type layerfrozen:LOGICAL + + :param layerblocked + :type layerblocked:LOGICAL + + :param layerstyles + :type layerstyles:SET(0,None,'ifcpresentationstyleselect', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__assigneditems , inherited3__identifier , layeron,layerfrozen,layerblocked,layerstyles, ): + ifcpresentationlayerassignment.__init__(self , inherited0__name , inherited1__description , inherited2__assigneditems , inherited3__identifier , ) + self.layeron = layeron + self.layerfrozen = layerfrozen + self.layerblocked = layerblocked + self.layerstyles = layerstyles + + @apply + def layeron(): + def fget( self ): + return self._layeron + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layeron is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._layeron = LOGICAL(value) + else: + self._layeron = value + return property(**locals()) + + @apply + def layerfrozen(): + def fget( self ): + return self._layerfrozen + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layerfrozen is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._layerfrozen = LOGICAL(value) + else: + self._layerfrozen = value + return property(**locals()) + + @apply + def layerblocked(): + def fget( self ): + return self._layerblocked + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layerblocked is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._layerblocked = LOGICAL(value) + else: + self._layerblocked = value + return property(**locals()) + + @apply + def layerstyles(): + def fget( self ): + return self._layerstyles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layerstyles is mantatory and can not be set to None') + if not check_type(value,SET(0,None,'ifcpresentationstyleselect', scope = schema_scope)): + self._layerstyles = SET(value) + else: + self._layerstyles = value + return property(**locals()) + +#################### + # ENTITY ifccompressortype # +#################### +class ifccompressortype(ifcflowmovingdevicetype): + '''Entity ifccompressortype definition. + + :param predefinedtype + :type predefinedtype:ifccompressortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowmovingdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccompressortypeenum): + self._predefinedtype = ifccompressortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifccompressortypeenum.self.userdefined) or ((self.predefinedtype == ifccompressortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifclightdistributiondata # +#################### +class ifclightdistributiondata(BaseEntityClass): + '''Entity ifclightdistributiondata definition. + + :param mainplaneangle + :type mainplaneangle:ifcplaneanglemeasure + + :param secondaryplaneangle + :type secondaryplaneangle:LIST(1,None,'REAL', scope = schema_scope) + + :param luminousintensity + :type luminousintensity:LIST(1,None,'REAL', scope = schema_scope) + ''' + def __init__( self , mainplaneangle,secondaryplaneangle,luminousintensity, ): + self.mainplaneangle = mainplaneangle + self.secondaryplaneangle = secondaryplaneangle + self.luminousintensity = luminousintensity + + @apply + def mainplaneangle(): + def fget( self ): + return self._mainplaneangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mainplaneangle is mantatory and can not be set to None') + if not check_type(value,ifcplaneanglemeasure): + self._mainplaneangle = ifcplaneanglemeasure(value) + else: + self._mainplaneangle = value + return property(**locals()) + + @apply + def secondaryplaneangle(): + def fget( self ): + return self._secondaryplaneangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument secondaryplaneangle is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'REAL', scope = schema_scope)): + self._secondaryplaneangle = LIST(value) + else: + self._secondaryplaneangle = value + return property(**locals()) + + @apply + def luminousintensity(): + def fget( self ): + return self._luminousintensity + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument luminousintensity is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'REAL', scope = schema_scope)): + self._luminousintensity = LIST(value) + else: + self._luminousintensity = value + return property(**locals()) + +#################### + # ENTITY ifcpipesegmenttype # +#################### +class ifcpipesegmenttype(ifcflowsegmenttype): + '''Entity ifcpipesegmenttype definition. + + :param predefinedtype + :type predefinedtype:ifcpipesegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowsegmenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcpipesegmenttypeenum): + self._predefinedtype = ifcpipesegmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcpipesegmenttypeenum.self.userdefined) or ((self.predefinedtype == ifcpipesegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcquantityvolume # +#################### +class ifcquantityvolume(ifcphysicalsimplequantity): + '''Entity ifcquantityvolume definition. + + :param volumevalue + :type volumevalue:ifcvolumemeasure + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , volumevalue, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.volumevalue = volumevalue + + @apply + def volumevalue(): + def fget( self ): + return self._volumevalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument volumevalue is mantatory and can not be set to None') + if not check_type(value,ifcvolumemeasure): + self._volumevalue = ifcvolumemeasure(value) + else: + self._volumevalue = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.volumeunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.volumevalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcaxis2placement2d # +#################### +class ifcaxis2placement2d(ifcplacement): + '''Entity ifcaxis2placement2d definition. + + :param refdirection + :type refdirection:ifcdirection + + :param p + :type p:LIST(2,2,'ifcdirection', scope = schema_scope) + ''' + def __init__( self , inherited0__location , refdirection, ): + ifcplacement.__init__(self , inherited0__location , ) + self.refdirection = refdirection + + @apply + def refdirection(): + def fget( self ): + return self._refdirection + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._refdirection = ifcdirection(value) + else: + self._refdirection = value + else: + self._refdirection = value + return property(**locals()) + + @apply + def p(): + def fget( self ): + attribute_eval = ifcbuild2axes(self.refdirection) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument p is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not EXISTS(self.refdirection)) or (self.refdirection.self.dim == 2)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.self.ifcplacement.self.location.self.dim == 2) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcchamferedgefeature # +#################### +class ifcchamferedgefeature(ifcedgefeature): + '''Entity ifcchamferedgefeature definition. + + :param width + :type width:ifcpositivelengthmeasure + + :param height + :type height:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__featurelength , width,height, ): + ifcedgefeature.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__featurelength , ) + self.width = width + self.height = height + + @apply + def width(): + def fget( self ): + return self._width + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._width = ifcpositivelengthmeasure(value) + else: + self._width = value + else: + self._width = value + return property(**locals()) + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._height = ifcpositivelengthmeasure(value) + else: + self._height = value + else: + self._height = value + return property(**locals()) + +#################### + # ENTITY ifcmateriallayer # +#################### +class ifcmateriallayer(BaseEntityClass): + '''Entity ifcmateriallayer definition. + + :param material + :type material:ifcmaterial + + :param layerthickness + :type layerthickness:ifcpositivelengthmeasure + + :param isventilated + :type isventilated:ifclogical + + :param tomateriallayerset + :type tomateriallayerset:ifcmateriallayerset + ''' + def __init__( self , material,layerthickness,isventilated, ): + self.material = material + self.layerthickness = layerthickness + self.isventilated = isventilated + + @apply + def material(): + def fget( self ): + return self._material + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmaterial): + self._material = ifcmaterial(value) + else: + self._material = value + else: + self._material = value + return property(**locals()) + + @apply + def layerthickness(): + def fget( self ): + return self._layerthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layerthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._layerthickness = ifcpositivelengthmeasure(value) + else: + self._layerthickness = value + return property(**locals()) + + @apply + def isventilated(): + def fget( self ): + return self._isventilated + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclogical): + self._isventilated = ifclogical(value) + else: + self._isventilated = value + else: + self._isventilated = value + return property(**locals()) + + @apply + def tomateriallayerset(): + def fget( self ): + return self._tomateriallayerset + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument tomateriallayerset is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcrightcircularcone # +#################### +class ifcrightcircularcone(ifccsgprimitive3d): + '''Entity ifcrightcircularcone definition. + + :param height + :type height:ifcpositivelengthmeasure + + :param bottomradius + :type bottomradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , height,bottomradius, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.height = height + self.bottomradius = bottomradius + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._height = ifcpositivelengthmeasure(value) + else: + self._height = value + return property(**locals()) + + @apply + def bottomradius(): + def fget( self ): + return self._bottomradius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bottomradius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._bottomradius = ifcpositivelengthmeasure(value) + else: + self._bottomradius = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralloadlinearforce # +#################### +class ifcstructuralloadlinearforce(ifcstructuralloadstatic): + '''Entity ifcstructuralloadlinearforce definition. + + :param linearforcex + :type linearforcex:ifclinearforcemeasure + + :param linearforcey + :type linearforcey:ifclinearforcemeasure + + :param linearforcez + :type linearforcez:ifclinearforcemeasure + + :param linearmomentx + :type linearmomentx:ifclinearmomentmeasure + + :param linearmomenty + :type linearmomenty:ifclinearmomentmeasure + + :param linearmomentz + :type linearmomentz:ifclinearmomentmeasure + ''' + def __init__( self , inherited0__name , linearforcex,linearforcey,linearforcez,linearmomentx,linearmomenty,linearmomentz, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.linearforcex = linearforcex + self.linearforcey = linearforcey + self.linearforcez = linearforcez + self.linearmomentx = linearmomentx + self.linearmomenty = linearmomenty + self.linearmomentz = linearmomentz + + @apply + def linearforcex(): + def fget( self ): + return self._linearforcex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearforcemeasure): + self._linearforcex = ifclinearforcemeasure(value) + else: + self._linearforcex = value + else: + self._linearforcex = value + return property(**locals()) + + @apply + def linearforcey(): + def fget( self ): + return self._linearforcey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearforcemeasure): + self._linearforcey = ifclinearforcemeasure(value) + else: + self._linearforcey = value + else: + self._linearforcey = value + return property(**locals()) + + @apply + def linearforcez(): + def fget( self ): + return self._linearforcez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearforcemeasure): + self._linearforcez = ifclinearforcemeasure(value) + else: + self._linearforcez = value + else: + self._linearforcez = value + return property(**locals()) + + @apply + def linearmomentx(): + def fget( self ): + return self._linearmomentx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearmomentmeasure): + self._linearmomentx = ifclinearmomentmeasure(value) + else: + self._linearmomentx = value + else: + self._linearmomentx = value + return property(**locals()) + + @apply + def linearmomenty(): + def fget( self ): + return self._linearmomenty + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearmomentmeasure): + self._linearmomenty = ifclinearmomentmeasure(value) + else: + self._linearmomenty = value + else: + self._linearmomenty = value + return property(**locals()) + + @apply + def linearmomentz(): + def fget( self ): + return self._linearmomentz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearmomentmeasure): + self._linearmomentz = ifclinearmomentmeasure(value) + else: + self._linearmomentz = value + else: + self._linearmomentz = value + return property(**locals()) + +#################### + # ENTITY ifcopenshell # +#################### +class ifcopenshell(ifcconnectedfaceset): + '''Entity ifcopenshell definition. + ''' + def __init__( self , inherited0__cfsfaces , ): + ifcconnectedfaceset.__init__(self , inherited0__cfsfaces , ) + +#################### + # ENTITY ifcwindow # +#################### +class ifcwindow(ifcbuildingelement): + '''Entity ifcwindow definition. + + :param overallheight + :type overallheight:ifcpositivelengthmeasure + + :param overallwidth + :type overallwidth:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , overallheight,overallwidth, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.overallheight = overallheight + self.overallwidth = overallwidth + + @apply + def overallheight(): + def fget( self ): + return self._overallheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._overallheight = ifcpositivelengthmeasure(value) + else: + self._overallheight = value + else: + self._overallheight = value + return property(**locals()) + + @apply + def overallwidth(): + def fget( self ): + return self._overallwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._overallwidth = ifcpositivelengthmeasure(value) + else: + self._overallwidth = value + else: + self._overallwidth = value + return property(**locals()) + +#################### + # ENTITY ifclibraryinformation # +#################### +class ifclibraryinformation(BaseEntityClass): + '''Entity ifclibraryinformation definition. + + :param name + :type name:ifclabel + + :param version + :type version:ifclabel + + :param publisher + :type publisher:ifcorganization + + :param versiondate + :type versiondate:ifccalendardate + + :param libraryreference + :type libraryreference:SET(1,None,'ifclibraryreference', scope = schema_scope) + ''' + def __init__( self , name,version,publisher,versiondate,libraryreference, ): + self.name = name + self.version = version + self.publisher = publisher + self.versiondate = versiondate + self.libraryreference = libraryreference + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def version(): + def fget( self ): + return self._version + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._version = ifclabel(value) + else: + self._version = value + else: + self._version = value + return property(**locals()) + + @apply + def publisher(): + def fget( self ): + return self._publisher + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcorganization): + self._publisher = ifcorganization(value) + else: + self._publisher = value + else: + self._publisher = value + return property(**locals()) + + @apply + def versiondate(): + def fget( self ): + return self._versiondate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccalendardate): + self._versiondate = ifccalendardate(value) + else: + self._versiondate = value + else: + self._versiondate = value + return property(**locals()) + + @apply + def libraryreference(): + def fget( self ): + return self._libraryreference + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifclibraryreference', scope = schema_scope)): + self._libraryreference = SET(value) + else: + self._libraryreference = value + else: + self._libraryreference = value + return property(**locals()) + +#################### + # ENTITY ifclightsourcespot # +#################### +class ifclightsourcespot(ifclightsourcepositional): + '''Entity ifclightsourcespot definition. + + :param orientation + :type orientation:ifcdirection + + :param concentrationexponent + :type concentrationexponent:ifcreal + + :param spreadangle + :type spreadangle:ifcpositiveplaneanglemeasure + + :param beamwidthangle + :type beamwidthangle:ifcpositiveplaneanglemeasure + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , inherited4__position , inherited5__radius , inherited6__constantattenuation , inherited7__distanceattenuation , inherited8__quadricattenuation , orientation,concentrationexponent,spreadangle,beamwidthangle, ): + ifclightsourcepositional.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , inherited4__position , inherited5__radius , inherited6__constantattenuation , inherited7__distanceattenuation , inherited8__quadricattenuation , ) + self.orientation = orientation + self.concentrationexponent = concentrationexponent + self.spreadangle = spreadangle + self.beamwidthangle = beamwidthangle + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._orientation = ifcdirection(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def concentrationexponent(): + def fget( self ): + return self._concentrationexponent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreal): + self._concentrationexponent = ifcreal(value) + else: + self._concentrationexponent = value + else: + self._concentrationexponent = value + return property(**locals()) + + @apply + def spreadangle(): + def fget( self ): + return self._spreadangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument spreadangle is mantatory and can not be set to None') + if not check_type(value,ifcpositiveplaneanglemeasure): + self._spreadangle = ifcpositiveplaneanglemeasure(value) + else: + self._spreadangle = value + return property(**locals()) + + @apply + def beamwidthangle(): + def fget( self ): + return self._beamwidthangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument beamwidthangle is mantatory and can not be set to None') + if not check_type(value,ifcpositiveplaneanglemeasure): + self._beamwidthangle = ifcpositiveplaneanglemeasure(value) + else: + self._beamwidthangle = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralsurfacemembervarying # +#################### +class ifcstructuralsurfacemembervarying(ifcstructuralsurfacemember): + '''Entity ifcstructuralsurfacemembervarying definition. + + :param subsequentthickness + :type subsequentthickness:LIST(2,None,'REAL', scope = schema_scope) + + :param varyingthicknesslocation + :type varyingthicknesslocation:ifcshapeaspect + + :param varyingthickness + :type varyingthickness:LIST(3,None,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__predefinedtype , inherited8__thickness , subsequentthickness,varyingthicknesslocation, ): + ifcstructuralsurfacemember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__predefinedtype , inherited8__thickness , ) + self.subsequentthickness = subsequentthickness + self.varyingthicknesslocation = varyingthicknesslocation + + @apply + def subsequentthickness(): + def fget( self ): + return self._subsequentthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument subsequentthickness is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._subsequentthickness = LIST(value) + else: + self._subsequentthickness = value + return property(**locals()) + + @apply + def varyingthicknesslocation(): + def fget( self ): + return self._varyingthicknesslocation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument varyingthicknesslocation is mantatory and can not be set to None') + if not check_type(value,ifcshapeaspect): + self._varyingthicknesslocation = ifcshapeaspect(value) + else: + self._varyingthicknesslocation = value + return property(**locals()) + + @apply + def varyingthickness(): + def fget( self ): + attribute_eval = ifcaddtobeginoflist(self.self.ifcstructuralsurfacemember.self.thickness,self.subsequentthickness) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument varyingthickness is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr61(self): + eval_wr61_wr = EXISTS(self.self.ifcstructuralsurfacemember.self.thickness) + if not eval_wr61_wr: + raise AssertionError('Rule wr61 violated') + else: + return eval_wr61_wr + + def wr62(self): + eval_wr62_wr = (SIZEOF(None) == 0) + if not eval_wr62_wr: + raise AssertionError('Rule wr62 violated') + else: + return eval_wr62_wr + + def wr63(self): + eval_wr63_wr = (SIZEOF(None) == 0) + if not eval_wr63_wr: + raise AssertionError('Rule wr63 violated') + else: + return eval_wr63_wr + + +#################### + # ENTITY ifcrelassociatesdocument # +#################### +class ifcrelassociatesdocument(ifcrelassociates): + '''Entity ifcrelassociatesdocument definition. + + :param relatingdocument + :type relatingdocument:ifcdocumentselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingdocument, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingdocument = relatingdocument + + @apply + def relatingdocument(): + def fget( self ): + return self._relatingdocument + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingdocument is mantatory and can not be set to None') + if not check_type(value,ifcdocumentselect): + self._relatingdocument = ifcdocumentselect(value) + else: + self._relatingdocument = value + return property(**locals()) + +#################### + # ENTITY ifctimeseriesschedule # +#################### +class ifctimeseriesschedule(ifccontrol): + '''Entity ifctimeseriesschedule definition. + + :param applicabledates + :type applicabledates:LIST(1,None,'ifcdatetimeselect', scope = schema_scope) + + :param timeseriesscheduletype + :type timeseriesscheduletype:ifctimeseriesscheduletypeenum + + :param timeseries + :type timeseries:ifctimeseries + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , applicabledates,timeseriesscheduletype,timeseries, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.applicabledates = applicabledates + self.timeseriesscheduletype = timeseriesscheduletype + self.timeseries = timeseries + + @apply + def applicabledates(): + def fget( self ): + return self._applicabledates + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcdatetimeselect', scope = schema_scope)): + self._applicabledates = LIST(value) + else: + self._applicabledates = value + else: + self._applicabledates = value + return property(**locals()) + + @apply + def timeseriesscheduletype(): + def fget( self ): + return self._timeseriesscheduletype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timeseriesscheduletype is mantatory and can not be set to None') + if not check_type(value,ifctimeseriesscheduletypeenum): + self._timeseriesscheduletype = ifctimeseriesscheduletypeenum(value) + else: + self._timeseriesscheduletype = value + return property(**locals()) + + @apply + def timeseries(): + def fget( self ): + return self._timeseries + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timeseries is mantatory and can not be set to None') + if not check_type(value,ifctimeseries): + self._timeseries = ifctimeseries(value) + else: + self._timeseries = value + return property(**locals()) + def wr41(self): + eval_wr41_wr = (( not (self.timeseriesscheduletype == ifctimeseriesscheduletypeenum.self.userdefined)) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + +#################### + # ENTITY ifcconditioncriterion # +#################### +class ifcconditioncriterion(ifccontrol): + '''Entity ifcconditioncriterion definition. + + :param criterion + :type criterion:ifcconditioncriterionselect + + :param criteriondatetime + :type criteriondatetime:ifcdatetimeselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , criterion,criteriondatetime, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.criterion = criterion + self.criteriondatetime = criteriondatetime + + @apply + def criterion(): + def fget( self ): + return self._criterion + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument criterion is mantatory and can not be set to None') + if not check_type(value,ifcconditioncriterionselect): + self._criterion = ifcconditioncriterionselect(value) + else: + self._criterion = value + return property(**locals()) + + @apply + def criteriondatetime(): + def fget( self ): + return self._criteriondatetime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument criteriondatetime is mantatory and can not be set to None') + if not check_type(value,ifcdatetimeselect): + self._criteriondatetime = ifcdatetimeselect(value) + else: + self._criteriondatetime = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcelectricdistributionpoint # +#################### +class ifcelectricdistributionpoint(ifcflowcontroller): + '''Entity ifcelectricdistributionpoint definition. + + :param distributionpointfunction + :type distributionpointfunction:ifcelectricdistributionpointfunctionenum + + :param userdefinedfunction + :type userdefinedfunction:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , distributionpointfunction,userdefinedfunction, ): + ifcflowcontroller.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.distributionpointfunction = distributionpointfunction + self.userdefinedfunction = userdefinedfunction + + @apply + def distributionpointfunction(): + def fget( self ): + return self._distributionpointfunction + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distributionpointfunction is mantatory and can not be set to None') + if not check_type(value,ifcelectricdistributionpointfunctionenum): + self._distributionpointfunction = ifcelectricdistributionpointfunctionenum(value) + else: + self._distributionpointfunction = value + return property(**locals()) + + @apply + def userdefinedfunction(): + def fget( self ): + return self._userdefinedfunction + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedfunction = ifclabel(value) + else: + self._userdefinedfunction = value + else: + self._userdefinedfunction = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = ((self.distributionpointfunction != ifcelectricdistributionpointfunctionenum.self.userdefined) or ((self.distributionpointfunction == ifcelectricdistributionpointfunctionenum.self.userdefined) and EXISTS(self.self.ifcelectricdistributionpoint.self.userdefinedfunction))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcpumptype # +#################### +class ifcpumptype(ifcflowmovingdevicetype): + '''Entity ifcpumptype definition. + + :param predefinedtype + :type predefinedtype:ifcpumptypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowmovingdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcpumptypeenum): + self._predefinedtype = ifcpumptypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.predefinedtype != ifcpumptypeenum.self.userdefined) or ((self.predefinedtype == ifcpumptypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcsphere # +#################### +class ifcsphere(ifccsgprimitive3d): + '''Entity ifcsphere definition. + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , radius, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifccurvestylefont # +#################### +class ifccurvestylefont(BaseEntityClass): + '''Entity ifccurvestylefont definition. + + :param name + :type name:ifclabel + + :param patternlist + :type patternlist:LIST(1,None,'ifccurvestylefontpattern', scope = schema_scope) + ''' + def __init__( self , name,patternlist, ): + self.name = name + self.patternlist = patternlist + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def patternlist(): + def fget( self ): + return self._patternlist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument patternlist is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifccurvestylefontpattern', scope = schema_scope)): + self._patternlist = LIST(value) + else: + self._patternlist = value + return property(**locals()) + +#################### + # ENTITY ifcexternallydefinedsymbol # +#################### +class ifcexternallydefinedsymbol(ifcexternalreference): + '''Entity ifcexternallydefinedsymbol definition. + ''' + def __init__( self , inherited0__location , inherited1__itemreference , inherited2__name , ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__itemreference , inherited2__name , ) + +#################### + # ENTITY ifcramp # +#################### +class ifcramp(ifcbuildingelement): + '''Entity ifcramp definition. + + :param shapetype + :type shapetype:ifcramptypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , shapetype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.shapetype = shapetype + + @apply + def shapetype(): + def fget( self ): + return self._shapetype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument shapetype is mantatory and can not be set to None') + if not check_type(value,ifcramptypeenum): + self._shapetype = ifcramptypeenum(value) + else: + self._shapetype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 0) or ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 1) and ( not EXISTS(self.self.ifcproduct.self.representation)))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcopeningelement # +#################### +class ifcopeningelement(ifcfeatureelementsubtraction): + '''Entity ifcopeningelement definition. + + :param hasfillings + :type hasfillings:SET(0,None,'ifcrelfillselement', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcfeatureelementsubtraction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def hasfillings(): + def fget( self ): + return self._hasfillings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasfillings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifccartesiantransformationoperator3dnonuniform # +#################### +class ifccartesiantransformationoperator3dnonuniform(ifccartesiantransformationoperator3d): + '''Entity ifccartesiantransformationoperator3dnonuniform definition. + + :param scale2 + :type scale2:REAL + + :param scale3 + :type scale3:REAL + + :param scl2 + :type scl2:REAL + + :param scl3 + :type scl3:REAL + ''' + def __init__( self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , inherited4__axis3 , scale2,scale3, ): + ifccartesiantransformationoperator3d.__init__(self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , inherited4__axis3 , ) + self.scale2 = scale2 + self.scale3 = scale3 + + @apply + def scale2(): + def fget( self ): + return self._scale2 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._scale2 = REAL(value) + else: + self._scale2 = value + else: + self._scale2 = value + return property(**locals()) + + @apply + def scale3(): + def fget( self ): + return self._scale3 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._scale3 = REAL(value) + else: + self._scale3 = value + else: + self._scale3 = value + return property(**locals()) + + @apply + def scl2(): + def fget( self ): + attribute_eval = NVL(self.scale2,self.self.ifccartesiantransformationoperator.self.scl) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scl2 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def scl3(): + def fget( self ): + attribute_eval = NVL(self.scale3,self.self.ifccartesiantransformationoperator.self.scl) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scl3 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.scl2 > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (self.scl3 > 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcscheduletimecontrol # +#################### +class ifcscheduletimecontrol(ifccontrol): + '''Entity ifcscheduletimecontrol definition. + + :param actualstart + :type actualstart:ifcdatetimeselect + + :param earlystart + :type earlystart:ifcdatetimeselect + + :param latestart + :type latestart:ifcdatetimeselect + + :param schedulestart + :type schedulestart:ifcdatetimeselect + + :param actualfinish + :type actualfinish:ifcdatetimeselect + + :param earlyfinish + :type earlyfinish:ifcdatetimeselect + + :param latefinish + :type latefinish:ifcdatetimeselect + + :param schedulefinish + :type schedulefinish:ifcdatetimeselect + + :param scheduleduration + :type scheduleduration:ifctimemeasure + + :param actualduration + :type actualduration:ifctimemeasure + + :param remainingtime + :type remainingtime:ifctimemeasure + + :param freefloat + :type freefloat:ifctimemeasure + + :param totalfloat + :type totalfloat:ifctimemeasure + + :param iscritical + :type iscritical:BOOLEAN + + :param statustime + :type statustime:ifcdatetimeselect + + :param startfloat + :type startfloat:ifctimemeasure + + :param finishfloat + :type finishfloat:ifctimemeasure + + :param completion + :type completion:ifcpositiveratiomeasure + + :param scheduletimecontrolassigned + :type scheduletimecontrolassigned:ifcrelassignstasks + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , actualstart,earlystart,latestart,schedulestart,actualfinish,earlyfinish,latefinish,schedulefinish,scheduleduration,actualduration,remainingtime,freefloat,totalfloat,iscritical,statustime,startfloat,finishfloat,completion, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.actualstart = actualstart + self.earlystart = earlystart + self.latestart = latestart + self.schedulestart = schedulestart + self.actualfinish = actualfinish + self.earlyfinish = earlyfinish + self.latefinish = latefinish + self.schedulefinish = schedulefinish + self.scheduleduration = scheduleduration + self.actualduration = actualduration + self.remainingtime = remainingtime + self.freefloat = freefloat + self.totalfloat = totalfloat + self.iscritical = iscritical + self.statustime = statustime + self.startfloat = startfloat + self.finishfloat = finishfloat + self.completion = completion + + @apply + def actualstart(): + def fget( self ): + return self._actualstart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._actualstart = ifcdatetimeselect(value) + else: + self._actualstart = value + else: + self._actualstart = value + return property(**locals()) + + @apply + def earlystart(): + def fget( self ): + return self._earlystart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._earlystart = ifcdatetimeselect(value) + else: + self._earlystart = value + else: + self._earlystart = value + return property(**locals()) + + @apply + def latestart(): + def fget( self ): + return self._latestart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._latestart = ifcdatetimeselect(value) + else: + self._latestart = value + else: + self._latestart = value + return property(**locals()) + + @apply + def schedulestart(): + def fget( self ): + return self._schedulestart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._schedulestart = ifcdatetimeselect(value) + else: + self._schedulestart = value + else: + self._schedulestart = value + return property(**locals()) + + @apply + def actualfinish(): + def fget( self ): + return self._actualfinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._actualfinish = ifcdatetimeselect(value) + else: + self._actualfinish = value + else: + self._actualfinish = value + return property(**locals()) + + @apply + def earlyfinish(): + def fget( self ): + return self._earlyfinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._earlyfinish = ifcdatetimeselect(value) + else: + self._earlyfinish = value + else: + self._earlyfinish = value + return property(**locals()) + + @apply + def latefinish(): + def fget( self ): + return self._latefinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._latefinish = ifcdatetimeselect(value) + else: + self._latefinish = value + else: + self._latefinish = value + return property(**locals()) + + @apply + def schedulefinish(): + def fget( self ): + return self._schedulefinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._schedulefinish = ifcdatetimeselect(value) + else: + self._schedulefinish = value + else: + self._schedulefinish = value + return property(**locals()) + + @apply + def scheduleduration(): + def fget( self ): + return self._scheduleduration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimemeasure): + self._scheduleduration = ifctimemeasure(value) + else: + self._scheduleduration = value + else: + self._scheduleduration = value + return property(**locals()) + + @apply + def actualduration(): + def fget( self ): + return self._actualduration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimemeasure): + self._actualduration = ifctimemeasure(value) + else: + self._actualduration = value + else: + self._actualduration = value + return property(**locals()) + + @apply + def remainingtime(): + def fget( self ): + return self._remainingtime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimemeasure): + self._remainingtime = ifctimemeasure(value) + else: + self._remainingtime = value + else: + self._remainingtime = value + return property(**locals()) + + @apply + def freefloat(): + def fget( self ): + return self._freefloat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimemeasure): + self._freefloat = ifctimemeasure(value) + else: + self._freefloat = value + else: + self._freefloat = value + return property(**locals()) + + @apply + def totalfloat(): + def fget( self ): + return self._totalfloat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimemeasure): + self._totalfloat = ifctimemeasure(value) + else: + self._totalfloat = value + else: + self._totalfloat = value + return property(**locals()) + + @apply + def iscritical(): + def fget( self ): + return self._iscritical + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._iscritical = BOOLEAN(value) + else: + self._iscritical = value + else: + self._iscritical = value + return property(**locals()) + + @apply + def statustime(): + def fget( self ): + return self._statustime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetimeselect): + self._statustime = ifcdatetimeselect(value) + else: + self._statustime = value + else: + self._statustime = value + return property(**locals()) + + @apply + def startfloat(): + def fget( self ): + return self._startfloat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimemeasure): + self._startfloat = ifctimemeasure(value) + else: + self._startfloat = value + else: + self._startfloat = value + return property(**locals()) + + @apply + def finishfloat(): + def fget( self ): + return self._finishfloat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimemeasure): + self._finishfloat = ifctimemeasure(value) + else: + self._finishfloat = value + else: + self._finishfloat = value + return property(**locals()) + + @apply + def completion(): + def fget( self ): + return self._completion + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._completion = ifcpositiveratiomeasure(value) + else: + self._completion = value + else: + self._completion = value + return property(**locals()) + + @apply + def scheduletimecontrolassigned(): + def fget( self ): + return self._scheduletimecontrolassigned + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument scheduletimecontrolassigned is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # FUNCTION ifcnormalise # +#################### +def ifcnormalise(arg,): + ''' + :param arg + :type arg:ifcvectorordirection + ''' + if ( not EXISTS(arg)): + return None + else: + ndim = arg.dim + if ('IFC2X3.IFCVECTOR' == TYPEOF(arg)): + # begin/end block + v.directionratios = arg.ifcvector.orientation.directionratios + vec.magnitude = arg.ifcvector.magnitude + vec.orientation = v + if (arg.magnitude == 0): + return None + else: + vec.magnitude = 1 + else: + v.directionratios = arg.directionratios + mag = 0 + for i in range(1,ndim,1): + mag = mag + (v.directionratios[i] * v.directionratios[i]) + if (mag > 0): + mag = SQRT(mag) + for i in range(1,ndim,1): + v.directionratios[i] = v.directionratios[i] / mag + if ('IFC2X3.IFCVECTOR' == TYPEOF(arg)): + vec.orientation = v + result = vec + else: + result = v + else: + return None + return result + +#################### + # FUNCTION ifcsamevalue # +#################### +def ifcsamevalue(value1,value2,epsilon,): + ''' + :param value1 + :type value1:REAL + :param value2 + :type value2:REAL + :param epsilon + :type epsilon:REAL + ''' + valideps = NVL(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + +#################### + # FUNCTION ifcsamevalidprecision # +#################### +def ifcsamevalidprecision(epsilon1,epsilon2,): + ''' + :param epsilon1 + :type epsilon1:REAL + :param epsilon2 + :type epsilon2:REAL + ''' + valideps1 = NVL(epsilon1,defaulteps) + valideps2 = NVL(epsilon2,defaulteps) + return (((0 < valideps1) and (valideps1 <= (derivationofeps * valideps2))) and (valideps2 <= (derivationofeps * valideps1))) and (valideps2 < uppereps) + +#################### + # FUNCTION ifcbuildaxes # +#################### +def ifcbuildaxes(axis,refdirection,): + ''' + :param axis + :type axis:ifcdirection + :param refdirection + :type refdirection:ifcdirection + ''' + d1 = NVL(ifcnormalise(axis),(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,0,1])) + d2 = ifcfirstprojaxis(d1,refdirection) + return [d2,ifcnormalise(ifccrossproduct(d1,d2)).ifcvector.orientation,d1] + +#################### + # FUNCTION ifcvectorsum # +#################### +def ifcvectorsum(arg1,arg2,): + ''' + :param arg1 + :type arg1:ifcvectorordirection + :param arg2 + :type arg2:ifcvectorordirection + ''' + if ((( not EXISTS(arg1)) or ( not EXISTS(arg2))) or (arg1.dim != arg2.dim)): + return None + else: + # begin/end block + if ('IFC2X3.IFCVECTOR' == TYPEOF(arg1)): + mag1 = arg1.ifcvector.magnitude + vec1 = arg1.ifcvector.orientation + else: + mag1 = 1 + vec1 = arg1 + if ('IFC2X3.IFCVECTOR' == TYPEOF(arg2)): + mag2 = arg2.ifcvector.magnitude + vec2 = arg2.ifcvector.orientation + else: + mag2 = 1 + vec2 = arg2 + vec1 = ifcnormalise(vec1) + vec2 = ifcnormalise(vec2) + ndim = SIZEOF(vec1.directionratios) + mag = 0 + res = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,ndim]) + for i in range(1,ndim,1): + res.directionratios[i] = (mag1 * vec1.directionratios[i]) + (mag2 * vec2.directionratios[i]) + mag = mag + (res.directionratios[i] * res.directionratios[i]) + if (mag > 0): + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(res,SQRT(mag)) + else: + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(vec1,0) + return result + +#################### + # FUNCTION ifcvectordifference # +#################### +def ifcvectordifference(arg1,arg2,): + ''' + :param arg1 + :type arg1:ifcvectorordirection + :param arg2 + :type arg2:ifcvectorordirection + ''' + if ((( not EXISTS(arg1)) or ( not EXISTS(arg2))) or (arg1.dim != arg2.dim)): + return None + else: + # begin/end block + if ('IFC2X3.IFCVECTOR' == TYPEOF(arg1)): + mag1 = arg1.ifcvector.magnitude + vec1 = arg1.ifcvector.orientation + else: + mag1 = 1 + vec1 = arg1 + if ('IFC2X3.IFCVECTOR' == TYPEOF(arg2)): + mag2 = arg2.ifcvector.magnitude + vec2 = arg2.ifcvector.orientation + else: + mag2 = 1 + vec2 = arg2 + vec1 = ifcnormalise(vec1) + vec2 = ifcnormalise(vec2) + ndim = SIZEOF(vec1.directionratios) + mag = 0 + res = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,ndim]) + for i in range(1,ndim,1): + res.directionratios[i] = (mag1 * vec1.directionratios[i]) - (mag2 * vec2.directionratios[i]) + mag = mag + (res.directionratios[i] * res.directionratios[i]) + if (mag > 0): + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(res,SQRT(mag)) + else: + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(vec1,0) + return result + +#################### + # FUNCTION ifccorrectlocalplacement # +#################### +def ifccorrectlocalplacement(axisplacement,relplacement,): + ''' + :param axisplacement + :type axisplacement:ifcaxis2placement + :param relplacement + :type relplacement:ifcobjectplacement + ''' + if (EXISTS(relplacement)): + if ('IFC2X3.IFCGRIDPLACEMENT' == TYPEOF(relplacement)): + return None + if ('IFC2X3.IFCLOCALPLACEMENT' == TYPEOF(relplacement)): + if ('IFC2X3.IFCAXIS2PLACEMENT2D' == TYPEOF(axisplacement)): + return TRUE + if ('IFC2X3.IFCAXIS2PLACEMENT3D' == TYPEOF(axisplacement)): + if (relplacement.relativeplacement.dim == 3): + return TRUE + else: + return FALSE + else: + return TRUE + return None + +#################### + # FUNCTION ifccorrectfillareastyle # +#################### +def ifccorrectfillareastyle(styles,): + ''' + :param styles + :type styles:(null) + ''' + external = SIZEOF(None) + hatching = SIZEOF(None) + tiles = SIZEOF(None) + colour = SIZEOF(None) + 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 + +#################### + # FUNCTION ifcuniquepropertyname # +#################### +def ifcuniquepropertyname(properties,): + ''' + :param properties + :type properties:(null) + ''' + for i in range(1,HIINDEX(properties),1): + names = names + properties[i].name + return SIZEOF(names) == SIZEOF(properties) + +#################### + # FUNCTION ifccurvedim # +#################### +def ifccurvedim(curve,): + ''' + :param curve + :type curve:ifccurve + ''' + if ('IFC2X3.IFCLINE' == TYPEOF(curve)): + return curve.ifcline.pnt.dim + if ('IFC2X3.IFCCONIC' == TYPEOF(curve)): + return curve.ifcconic.position.dim + if ('IFC2X3.IFCPOLYLINE' == TYPEOF(curve)): + return curve.ifcpolyline.points[1].dim + if ('IFC2X3.IFCTRIMMEDCURVE' == TYPEOF(curve)): + return ifccurvedim(curve.ifctrimmedcurve.basiscurve) + if ('IFC2X3.IFCCOMPOSITECURVE' == TYPEOF(curve)): + return curve.ifccompositecurve.segments[1].dim + if ('IFC2X3.IFCBSPLINECURVE' == TYPEOF(curve)): + return curve.ifcbsplinecurve.controlpointslist[1].dim + if ('IFC2X3.IFCOFFSETCURVE2D' == TYPEOF(curve)): + return 2 + if ('IFC2X3.IFCOFFSETCURVE3D' == TYPEOF(curve)): + return 3 + return None + +#################### + # FUNCTION ifcsamedirection # +#################### +def ifcsamedirection(dir1,dir2,epsilon,): + ''' + :param dir1 + :type dir1:ifcdirection + :param dir2 + :type dir2:ifcdirection + :param epsilon + :type epsilon:REAL + ''' + if (SIZEOF(dir1.directionratios) > 2): + dir1z = dir1.directionratios[3] + if (SIZEOF(dir2.directionratios) > 2): + dir2z = dir2.directionratios[3] + return (ifcsamevalue(dir1x,dir2x,epsilon) and ifcsamevalue(dir1y,dir2y,epsilon)) and ifcsamevalue(dir1z,dir2z,epsilon) + +#################### + # FUNCTION ifclisttoarray # +#################### +def ifclisttoarray(lis,low,u,): + ''' + :param lis + :type lis:(null) + :param low + :type low:INTEGER + :param u + :type u:INTEGER + ''' + n = SIZEOF(lis) + if (n != ((u - low) + 1)): + return None + else: + res = [lis[1],n] + for i in range(2,n,1): + res[(low + i) - 1] = lis[i] + return res + +#################### + # FUNCTION ifcvalidtime # +#################### +def ifcvalidtime(time,): + ''' + :param time + :type time:ifclocaltime + ''' + if (EXISTS(time.secondcomponent)): + return EXISTS(time.minutecomponent) + else: + return TRUE + +#################### + # FUNCTION ifctopologyrepresentationtypes # +#################### +def ifctopologyrepresentationtypes(reptype,items,): + ''' + :param reptype + :type reptype:STRING + :param items + :type items:(null) + ''' + case_selector = reptype + if case_selector == 'Vertex': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Edge': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Path': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Face': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Shell': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Undefined': + return TRUE + else: + return None + return count == SIZEOF(items) + +#################### + # FUNCTION ifccorrectunitassignment # +#################### +def ifccorrectunitassignment(units,): + ''' + :param units + :type units:(null) + ''' + namedunitnumber = SIZEOF(None) + derivedunitnumber = SIZEOF(None) + monetaryunitnumber = SIZEOF(None) + for i in range(1,SIZEOF(units),1): + if (('IFC2X3.IFCNAMEDUNIT' == TYPEOF(units[i])) and ( not (units[i].ifcnamedunit.unittype == ifcunitenum.userdefined))): + namedunitnames = namedunitnames + units[i].ifcnamedunit.unittype + if (('IFC2X3.IFCDERIVEDUNIT' == TYPEOF(units[i])) and ( not (units[i].ifcderivedunit.unittype == ifcderivedunitenum.userdefined))): + derivedunitnames = derivedunitnames + units[i].ifcderivedunit.unittype + return ((SIZEOF(namedunitnames) == namedunitnumber) and (SIZEOF(derivedunitnames) == derivedunitnumber)) and (monetaryunitnumber <= 1) + +#################### + # FUNCTION ifcdotproduct # +#################### +def ifcdotproduct(arg1,arg2,): + ''' + :param arg1 + :type arg1:ifcdirection + :param arg2 + :type arg2:ifcdirection + ''' + if (( not EXISTS(arg1)) or ( not EXISTS(arg2))): + scalar = None + else: + if (arg1.dim != arg2.dim): + scalar = None + else: + # begin/end block + vec1 = ifcnormalise(arg1) + vec2 = ifcnormalise(arg2) + ndim = arg1.dim + scalar = 0 + for i in range(1,ndim,1): + scalar = scalar + (vec1.directionratios[i] * vec2.directionratios[i]) + return scalar + +#################### + # FUNCTION ifcaddtobeginoflist # +#################### +def ifcaddtobeginoflist(ascalar,alist,): + ''' + :param ascalar + :type ascalar:(null) + :param alist + :type alist:(null) + ''' + if ( not EXISTS(ascalar)): + result = alist + else: + result = result + ascalar + if (HIINDEX(alist) >= 1): + for i in range(1,HIINDEX(alist),1): + result[i + 1] = alist[i] + return result + +#################### + # FUNCTION ifcfirstprojaxis # +#################### +def ifcfirstprojaxis(zaxis,arg,): + ''' + :param zaxis + :type zaxis:ifcdirection + :param arg + :type arg:ifcdirection + ''' + if ( not EXISTS(zaxis)): + return None + else: + z = ifcnormalise(zaxis) + if ( not EXISTS(arg)): + if (z.directionratios != [1,0,0]): + v = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([1,0,0]) + else: + v = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,1,0]) + else: + if (arg.dim != 3): + return None + if (ifccrossproduct(arg,z).magnitude == 0): + return None + else: + v = ifcnormalise(arg) + xvec = ifcscalartimesvector(ifcdotproduct(v,z),z) + xaxis = ifcvectordifference(v,xvec).orientation + xaxis = ifcnormalise(xaxis) + return xaxis + +#################### + # FUNCTION ifcshaperepresentationtypes # +#################### +def ifcshaperepresentationtypes(reptype,items,): + ''' + :param reptype + :type reptype:STRING + :param items + :type items:(null) + ''' + case_selector = reptype + if case_selector == 'Curve2D': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Annotation2D': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'GeometricSet': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'GeometricCurveSet': + # begin/end block + count = SIZEOF(None) + for i in range(1,HIINDEX(items),1): + if ('IFC2X3.IFCGEOMETRICSET' == TYPEOF(items[i])): + if (SIZEOF(None) > 0): + count = count - 1 + elif case_selector == 'SurfaceModel': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'SolidModel': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'SweptSolid': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'CSG': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Clipping': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'AdvancedSweptSolid': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Brep': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'BoundingBox': + # begin/end block + count = SIZEOF(None) + if (SIZEOF(items) > 1): + count = 0 + elif case_selector == 'SectionedSpine': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'MappedRepresentation': + # begin/end block + count = SIZEOF(None) + else: + return None + return count == SIZEOF(items) + +#################### + # FUNCTION ifcpathheadtotail # +#################### +def ifcpathheadtotail(apath,): + ''' + :param apath + :type apath:ifcpath + ''' + n = SIZEOF(apath.edgelist) + for i in range(2,n,1): + p = p and (apath.edgelist[i - 1].edgeend == apath.edgelist[i].edgestart) + return p + +#################### + # FUNCTION ifcsecondprojaxis # +#################### +def ifcsecondprojaxis(zaxis,xaxis,arg,): + ''' + :param zaxis + :type zaxis:ifcdirection + :param xaxis + :type xaxis:ifcdirection + :param arg + :type arg:ifcdirection + ''' + if ( not EXISTS(arg)): + v = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,1,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 + +#################### + # FUNCTION ifcderivedimensionalexponents # +#################### +def ifcderivedimensionalexponents(unitelements,): + ''' + :param unitelements + :type unitelements:(null) + ''' + for i in range(LOINDEX(unitelements),HIINDEX(unitelements),1): + result.lengthexponent = result.lengthexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.lengthexponent) + result.massexponent = result.massexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.massexponent) + result.timeexponent = result.timeexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.timeexponent) + result.electriccurrentexponent = result.electriccurrentexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.electriccurrentexponent) + result.thermodynamictemperatureexponent = result.thermodynamictemperatureexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.thermodynamictemperatureexponent) + result.amountofsubstanceexponent = result.amountofsubstanceexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.amountofsubstanceexponent) + result.luminousintensityexponent = result.luminousintensityexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.luminousintensityexponent) + return result + +#################### + # FUNCTION ifcbooleanchoose # +#################### +def ifcbooleanchoose(b,choice1,choice2,): + ''' + :param b + :type b:BOOLEAN + :param choice1 + :type choice1:(null) + :param choice2 + :type choice2:(null) + ''' + if (b): + return choice1 + else: + return choice2 + +#################### + # FUNCTION ifcscalartimesvector # +#################### +def ifcscalartimesvector(scalar,vec,): + ''' + :param scalar + :type scalar:REAL + :param vec + :type vec:ifcvectorordirection + ''' + if (( not EXISTS(scalar)) or ( not EXISTS(vec))): + return None + else: + if ('IFC2X3.IFCVECTOR' == TYPEOF(vec)): + v = vec.ifcvector.orientation + mag = scalar * vec.ifcvector.magnitude + else: + v = vec + mag = scalar + if (mag < 0): + for i in range(1,SIZEOF(v.directionratios),1): + v.directionratios[i] = -v.directionratios[i] + mag = -mag + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(ifcnormalise(v),mag) + return result + +#################### + # FUNCTION ifcleapyear # +#################### +def ifcleapyear(year,): + ''' + :param year + :type year:INTEGER + ''' + if ((((year % 4) == 0) and ((year % 100) != 0)) or ((year % 400) == 0)): + return TRUE + else: + return FALSE + +#################### + # FUNCTION ifcbaseaxis # +#################### +def ifcbaseaxis(dim,axis1,axis2,axis3,): + ''' + :param dim + :type dim:INTEGER + :param axis1 + :type axis1:ifcdirection + :param axis2 + :type axis2:ifcdirection + :param axis3 + :type axis3:ifcdirection + ''' + if (dim == 3): + d1 = NVL(ifcnormalise(axis3),(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,0,1])) + 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]) + if (factor < 0): + u[2].directionratios[1] = -u[2].directionratios[1] + u[2].directionratios[2] = -u[2].directionratios[2] + else: + if (EXISTS(axis2)): + d1 = ifcnormalise(axis2) + u = [ifcorthogonalcomplement(d1),d1] + u[1].directionratios[1] = -u[1].directionratios[1] + u[1].directionratios[2] = -u[1].directionratios[2] + else: + u = [(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([1,0]),(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,1])] + return u + +#################### + # FUNCTION ifcorthogonalcomplement # +#################### +def ifcorthogonalcomplement(vec,): + ''' + :param vec + :type vec:ifcdirection + ''' + if (( not EXISTS(vec)) or (vec.dim != 2)): + return None + else: + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([-vec.directionratios[2],vec.directionratios[1]]) + return result + +#################### + # FUNCTION ifcloopheadtotail # +#################### +def ifcloopheadtotail(aloop,): + ''' + :param aloop + :type aloop:ifcedgeloop + ''' + n = SIZEOF(aloop.edgelist) + for i in range(2,n,1): + p = p and (aloop.edgelist[i - 1].edgeend == aloop.edgelist[i].edgestart) + return p + +#################### + # FUNCTION ifccorrectdimensions # +#################### +def ifccorrectdimensions(m,dim,): + ''' + :param m + :type m:ifcunitenum + :param dim + :type dim:ifcdimensionalexponents + ''' + case_selector = m + if case_selector == lengthunit: + if (dim == ifcdimensionalexponents(1,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == massunit: + if (dim == ifcdimensionalexponents(0,1,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == timeunit: + if (dim == ifcdimensionalexponents(0,0,1,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electriccurrentunit: + if (dim == ifcdimensionalexponents(0,0,0,1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == thermodynamictemperatureunit: + if (dim == ifcdimensionalexponents(0,0,0,0,1,0,0)): + return TRUE + else: + return FALSE + elif case_selector == amountofsubstanceunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,1,0)): + return TRUE + else: + return FALSE + elif case_selector == luminousintensityunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,0,1)): + return TRUE + else: + return FALSE + elif case_selector == planeangleunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == solidangleunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == areaunit: + if (dim == ifcdimensionalexponents(2,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == volumeunit: + if (dim == ifcdimensionalexponents(3,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == absorbeddoseunit: + if (dim == ifcdimensionalexponents(2,0,-2,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == radioactivityunit: + if (dim == ifcdimensionalexponents(0,0,-1,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electriccapacitanceunit: + if (dim == ifcdimensionalexponents(-2,1,4,1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == doseequivalentunit: + if (dim == ifcdimensionalexponents(2,0,-2,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electricchargeunit: + if (dim == ifcdimensionalexponents(0,0,1,1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electricconductanceunit: + if (dim == ifcdimensionalexponents(-2,-1,3,2,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electricvoltageunit: + if (dim == ifcdimensionalexponents(2,1,-3,-1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electricresistanceunit: + if (dim == ifcdimensionalexponents(2,1,-3,-2,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == energyunit: + if (dim == ifcdimensionalexponents(2,1,-2,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == forceunit: + if (dim == ifcdimensionalexponents(1,1,-2,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == frequencyunit: + if (dim == ifcdimensionalexponents(0,0,-1,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == inductanceunit: + if (dim == ifcdimensionalexponents(2,1,-2,-2,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == illuminanceunit: + if (dim == ifcdimensionalexponents(-2,0,0,0,0,0,1)): + return TRUE + else: + return FALSE + elif case_selector == luminousfluxunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,0,1)): + return TRUE + else: + return FALSE + elif case_selector == magneticfluxunit: + if (dim == ifcdimensionalexponents(2,1,-2,-1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == magneticfluxdensityunit: + if (dim == ifcdimensionalexponents(0,1,-2,-1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == powerunit: + if (dim == ifcdimensionalexponents(2,1,-3,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == pressureunit: + if (dim == ifcdimensionalexponents(-1,1,-2,0,0,0,0)): + return TRUE + else: + return FALSE + else: + return UNKNOWN + +#################### + # FUNCTION ifcdimensionsforsiunit # +#################### +def ifcdimensionsforsiunit(n,): + ''' + :param n + :type n:ifcsiunitname + ''' + case_selector = n + if case_selector == metre: + return ifcdimensionalexponents(1,0,0,0,0,0,0) + elif case_selector == square_metre: + return ifcdimensionalexponents(2,0,0,0,0,0,0) + elif case_selector == cubic_metre: + return ifcdimensionalexponents(3,0,0,0,0,0,0) + elif case_selector == gram: + return ifcdimensionalexponents(0,1,0,0,0,0,0) + elif case_selector == second: + return ifcdimensionalexponents(0,0,1,0,0,0,0) + elif case_selector == ampere: + return ifcdimensionalexponents(0,0,0,1,0,0,0) + elif case_selector == kelvin: + return ifcdimensionalexponents(0,0,0,0,1,0,0) + elif case_selector == mole: + return ifcdimensionalexponents(0,0,0,0,0,1,0) + elif case_selector == candela: + return ifcdimensionalexponents(0,0,0,0,0,0,1) + elif case_selector == radian: + return ifcdimensionalexponents(0,0,0,0,0,0,0) + elif case_selector == steradian: + return ifcdimensionalexponents(0,0,0,0,0,0,0) + elif case_selector == hertz: + return ifcdimensionalexponents(0,0,-1,0,0,0,0) + elif case_selector == newton: + return ifcdimensionalexponents(1,1,-2,0,0,0,0) + elif case_selector == pascal: + return ifcdimensionalexponents(-1,1,-2,0,0,0,0) + elif case_selector == joule: + return ifcdimensionalexponents(2,1,-2,0,0,0,0) + elif case_selector == watt: + return ifcdimensionalexponents(2,1,-3,0,0,0,0) + elif case_selector == coulomb: + return ifcdimensionalexponents(0,0,1,1,0,0,0) + elif case_selector == volt: + return ifcdimensionalexponents(2,1,-3,-1,0,0,0) + elif case_selector == farad: + return ifcdimensionalexponents(-2,-1,4,1,0,0,0) + elif case_selector == ohm: + return ifcdimensionalexponents(2,1,-3,-2,0,0,0) + elif case_selector == siemens: + return ifcdimensionalexponents(-2,-1,3,2,0,0,0) + elif case_selector == weber: + return ifcdimensionalexponents(2,1,-2,-1,0,0,0) + elif case_selector == tesla: + return ifcdimensionalexponents(0,1,-2,-1,0,0,0) + elif case_selector == henry: + return ifcdimensionalexponents(2,1,-2,-2,0,0,0) + elif case_selector == degree_celsius: + return ifcdimensionalexponents(0,0,0,0,1,0,0) + elif case_selector == lumen: + return ifcdimensionalexponents(0,0,0,0,0,0,1) + elif case_selector == lux: + return ifcdimensionalexponents(-2,0,0,0,0,0,1) + elif case_selector == becquerel: + return ifcdimensionalexponents(0,0,-1,0,0,0,0) + elif case_selector == gray: + return ifcdimensionalexponents(2,0,-2,0,0,0,0) + elif case_selector == sievert: + return ifcdimensionalexponents(2,0,-2,0,0,0,0) + else: + return ifcdimensionalexponents(0,0,0,0,0,0,0) + +#################### + # FUNCTION ifcmlstotalthickness # +#################### +def ifcmlstotalthickness(layerset,): + ''' + :param layerset + :type layerset:ifcmateriallayerset + ''' + if (SIZEOF(layerset.materiallayers) > 1): + for i in range(2,HIINDEX(layerset.materiallayers),1): + max = max + layerset.materiallayers[i].layerthickness + return max + +#################### + # FUNCTION ifccorrectobjectassignment # +#################### +def ifccorrectobjectassignment(constraint,objects,): + ''' + :param constraint + :type constraint:ifcobjecttypeenum + :param objects + :type objects:(null) + ''' + if ( not EXISTS(constraint)): + return TRUE + case_selector = constraint + if case_selector == ifcobjecttypeenum.notdefined: + return TRUE + elif case_selector == ifcobjecttypeenum.product: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.process: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.control: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.resource: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.actor: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.group: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.project: + # begin/end block + count = SIZEOF(None) + return count == 0 + else: + return None + +#################### + # FUNCTION ifcvalidcalendardate # +#################### +def ifcvalidcalendardate(date,): + ''' + :param date + :type date:ifccalendardate + ''' + if ( not ((1 <= date.daycomponent) and (date.daycomponent <= 31))): + return FALSE + case_selector = date.monthcomponent + if case_selector == 4: + return (1 <= date.daycomponent) and (date.daycomponent <= 30) + elif case_selector == 6: + return (1 <= date.daycomponent) and (date.daycomponent <= 30) + elif case_selector == 9: + return (1 <= date.daycomponent) and (date.daycomponent <= 30) + elif case_selector == 11: + return (1 <= date.daycomponent) and (date.daycomponent <= 30) + elif case_selector == 2: + # begin/end block + if (ifcleapyear(date.yearcomponent)): + return (1 <= date.daycomponent) and (date.daycomponent <= 29) + else: + return (1 <= date.daycomponent) and (date.daycomponent <= 28) + else: + return TRUE + +#################### + # FUNCTION ifccurveweightspositive # +#################### +def ifccurveweightspositive(b,): + ''' + :param b + :type b:ifcrationalbeziercurve + ''' + for i in range(0,b.upperindexoncontrolpoints,1): + if (b.weights[i] <= 0): + result = FALSE + return result + return result + +#################### + # FUNCTION ifcsameaxis2placement # +#################### +def ifcsameaxis2placement(ap1,ap2,epsilon,): + ''' + :param ap1 + :type ap1:ifcaxis2placement + :param ap2 + :type ap2:ifcaxis2placement + :param epsilon + :type epsilon:REAL + ''' + return (ifcsamedirection(ap1.p[1],ap2.p[1],epsilon) and ifcsamedirection(ap1.p[2],ap2.p[2],epsilon)) and ifcsamecartesianpoint(ap1.location,ap1.location,epsilon) + +#################### + # FUNCTION ifcbuild2axes # +#################### +def ifcbuild2axes(refdirection,): + ''' + :param refdirection + :type refdirection:ifcdirection + ''' + return [d,ifcorthogonalcomplement(d)] + +#################### + # FUNCTION ifccrossproduct # +#################### +def ifccrossproduct(arg1,arg2,): + ''' + :param arg1 + :type arg1:ifcdirection + :param arg2 + :type arg2:ifcdirection + ''' + if ((( not EXISTS(arg1)) or (arg1.dim == 2)) or (( not EXISTS(arg2)) or (arg2.dim == 2))): + return None + else: + # begin/end block + v1 = ifcnormalise(arg1).directionratios + v2 = ifcnormalise(arg2).directionratios + res = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([(v1[2] * v2[3]) - (v1[3] * v2[2]),(v1[3] * v2[1]) - (v1[1] * v2[3]),(v1[1] * v2[2]) - (v1[2] * v2[1])]) + mag = 0 + for i in range(1,3,1): + mag = mag + (res.directionratios[i] * res.directionratios[i]) + if (mag > 0): + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(res,SQRT(mag)) + else: + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(arg1,0) + return result + +#################### + # FUNCTION ifcsamecartesianpoint # +#################### +def ifcsamecartesianpoint(cp1,cp2,epsilon,): + ''' + :param cp1 + :type cp1:ifccartesianpoint + :param cp2 + :type cp2:ifccartesianpoint + :param epsilon + :type epsilon:REAL + ''' + if (SIZEOF(cp1.coordinates) > 2): + cp1z = cp1.coordinates[3] + if (SIZEOF(cp2.coordinates) > 2): + cp2z = cp2.coordinates[3] + return (ifcsamevalue(cp1x,cp2x,epsilon) and ifcsamevalue(cp1y,cp2y,epsilon)) and ifcsamevalue(cp1z,cp2z,epsilon) + +#################### + # RULE ifcsingleprojectinstance # +#################### +ifcsingleprojectinstance = Rule() + +#################### + # RULE ifcrepresentationcontextsamewcs # +#################### +ifcrepresentationcontextsamewcs = Rule() diff --git a/src/Mod/Import/App/ifc4.py b/src/Mod/Import/App/ifc4.py new file mode 100644 index 000000000..5f60cd306 --- /dev/null +++ b/src/Mod/Import/App/ifc4.py @@ -0,0 +1,43883 @@ +# This file was generated by fedex_python. You probably don't want to edit +# it since your modifications will be lost if fedex_plus is used to +# regenerate it. +import sys + +from SCL.SCLBase import * +from SCL.SimpleDataTypes import * +from SCL.ConstructedDataTypes import * +from SCL.AggregationDataTypes import * +from SCL.TypeChecker import check_type +from SCL.Builtin import * +from SCL.Rules import * + +schema_name = 'ifc4' + +schema_scope = sys.modules[__name__] + +# Defined datatype ifccardinalpointreference +class ifccardinalpointreference(INTEGER): + def __init__(self,*kargs): + pass + self.greaterthanzero() + + def greaterthanzero(self): + eval_greaterthanzero_wr = (self > 0) + if not eval_greaterthanzero_wr: + raise AssertionError('Rule greaterthanzero violated') + else: + return eval_greaterthanzero_wr + +# Defined datatype ifcloadgrouptypeenum +class ifcloadgrouptypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmodulusoflinearsubgradereactionmeasure +class ifcmodulusoflinearsubgradereactionmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdate +class ifcdate(STRING): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifchatchlinedistanceselect +ifchatchlinedistanceselect = SELECT( + 'ifcpositivelengthmeasure', + 'ifcvector', + scope = schema_scope) +# SELECT TYPE ifcshell +ifcshell = SELECT( + 'ifcclosedshell', + 'ifcopenshell', + scope = schema_scope) +# Defined datatype ifcprotectivedevicetypeenum +class ifcprotectivedevicetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclanguageid +class ifclanguageid(ifcidentifier): + def __init__(self,*kargs): + pass + +# Defined datatype ifclinearforcemeasure +class ifclinearforcemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcassemblyplaceenum +class ifcassemblyplaceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcchimneytypeenum +class ifcchimneytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcroleenum +class ifcroleenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsoundpowermeasure +class ifcsoundpowermeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdistributionporttypeenum +class ifcdistributionporttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsiunitname +class ifcsiunitname(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcairtoairheatrecoverytypeenum +class ifcairtoairheatrecoverytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsolidorshell +ifcsolidorshell = SELECT( + 'ifcclosedshell', + 'ifcsolidmodel', + scope = schema_scope) +# Defined datatype ifcanalysistheorytypeenum +class ifcanalysistheorytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcchangeactionenum +class ifcchangeactionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoorpaneloperationenum +class ifcdoorpaneloperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctemperaturerateofchangemeasure +class ifctemperaturerateofchangemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowpaneloperationenum +class ifcwindowpaneloperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcslabtypeenum +class ifcslabtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricconductancemeasure +class ifcelectricconductancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifckinematicviscositymeasure +class ifckinematicviscositymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclinearvelocitymeasure +class ifclinearvelocitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsoundpressurelevelmeasure +class ifcsoundpressurelevelmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctimemeasure +class ifctimemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsurfacefeaturetypeenum +class ifcsurfacefeaturetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcfillstyleselect +ifcfillstyleselect = SELECT( + 'ifccolour', + 'ifcexternallydefinedhatchstyle', + 'ifcfillareastylehatching', + 'ifcfillareastyletiles', + scope = schema_scope) +# SELECT TYPE ifcstructuralactivityassignmentselect +ifcstructuralactivityassignmentselect = SELECT( + 'ifcelement', + 'ifcstructuralitem', + scope = schema_scope) +# Defined datatype ifcreflectancemethodenum +class ifcreflectancemethodenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctransformertypeenum +class ifctransformertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccsgselect +ifccsgselect = SELECT( + 'ifcbooleanresult', + 'ifccsgprimitive3d', + scope = schema_scope) +# SELECT TYPE ifcmaterialselect +ifcmaterialselect = SELECT( + 'ifcmaterialdefinition', + 'ifcmateriallist', + 'ifcmaterialusagedefinition', + scope = schema_scope) +# Defined datatype ifcelectriccapacitancemeasure +class ifcelectriccapacitancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfrequencymeasure +class ifcfrequencymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcidentifier +class ifcidentifier(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdirectionsenseenum +class ifcdirectionsenseenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcvalue +ifcvalue = SELECT( + 'ifcderivedmeasurevalue', + 'ifcmeasurevalue', + 'ifcsimplevalue', + scope = schema_scope) +# Defined datatype ifcdiscreteaccessorytypeenum +class ifcdiscreteaccessorytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcductsilencertypeenum +class ifcductsilencertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvoidingfeaturetypeenum +class ifcvoidingfeaturetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclabel +class ifclabel(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcactionsourcetypeenum +class ifcactionsourcetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctendontypeenum +class ifctendontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpressuremeasure +class ifcpressuremeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctransitioncode +class ifctransitioncode(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcactionrequesttypeenum +class ifcactionrequesttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsystemfurnitureelementtypeenum +class ifcsystemfurnitureelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcstyleassignmentselect +ifcstyleassignmentselect = SELECT( + 'ifcpresentationstyle', + 'ifcpresentationstyleassignment', + scope = schema_scope) +# Defined datatype ifctextalignment +class ifctextalignment(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['left','right','center','justify']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcthermalresistancemeasure +class ifcthermalresistancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricmotortypeenum +class ifcelectricmotortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctanktypeenum +class ifctanktypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcforcemeasure +class ifcforcemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcheatexchangertypeenum +class ifcheatexchangertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccurveonsurface +ifccurveonsurface = SELECT( + 'ifccompositecurveonsurface', + 'ifcpcurve', + scope = schema_scope) +# Defined datatype ifccoiltypeenum +class ifccoiltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrotationalmassmeasure +class ifcrotationalmassmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsectionalareaintegralmeasure +class ifcsectionalareaintegralmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclengthmeasure +class ifclengthmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowpanelpositionenum +class ifcwindowpanelpositionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcluminousintensitydistributionmeasure +class ifcluminousintensitydistributionmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrotationalstiffnessmeasure +class ifcrotationalstiffnessmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcanalysismodeltypeenum +class ifcanalysismodeltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsoundpressuremeasure +class ifcsoundpressuremeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccrewresourcetypeenum +class ifccrewresourcetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccolour +ifccolour = SELECT( + 'ifccolourspecification', + 'ifcpredefinedcolour', + scope = schema_scope) +# Defined datatype ifcspecularroughness +class ifcspecularroughness(REAL): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self <= 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# SELECT TYPE ifcappliedvalueselect +ifcappliedvalueselect = SELECT( + 'ifcmeasurewithunit', + 'ifcreference', + 'ifcvalue', + scope = schema_scope) +# SELECT TYPE ifcclassificationreferenceselect +ifcclassificationreferenceselect = SELECT( + 'ifcclassification', + 'ifcclassificationreference', + scope = schema_scope) +# Defined datatype ifcproceduretypeenum +class ifcproceduretypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrecurrencetypeenum +class ifcrecurrencetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcheatingvaluemeasure +class ifcheatingvaluemeasure(REAL): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcinductancemeasure +class ifcinductancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccurtainwalltypeenum +class ifccurtainwalltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmassperlengthmeasure +class ifcmassperlengthmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctexttransformation +class ifctexttransformation(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['capitalize','uppercase','lowercase','none']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcactuatortypeenum +class ifcactuatortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifchumidifiertypeenum +class ifchumidifiertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcconnectiontypeenum +class ifcconnectiontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccontrollertypeenum +class ifccontrollertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricgeneratortypeenum +class ifcelectricgeneratortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwasteterminaltypeenum +class ifcwasteterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcshearmodulusmeasure +class ifcshearmodulusmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclamptypeenum +class ifclamptypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcresourceobjectselect +ifcresourceobjectselect = SELECT( + 'ifcactorrole', + 'ifcappliedvalue', + 'ifcapproval', + 'ifcconstraint', + 'ifccontextdependentunit', + 'ifcconversionbasedunit', + 'ifcexternalinformation', + 'ifcexternalreference', + 'ifcmaterialdefinition', + 'ifcorganization', + 'ifcperson', + 'ifcpersonandorganization', + 'ifcphysicalquantity', + 'ifcprofiledef', + 'ifcpropertyabstraction', + 'ifctimeseries', + scope = schema_scope) +# Defined datatype ifcdatetime +class ifcdatetime(STRING): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcpresentationstyleselect +ifcpresentationstyleselect = SELECT( + 'ifccurvestyle', + 'ifcfillareastyle', + 'ifcnullstyle', + 'ifcsurfacestyle', + 'ifctextstyle', + scope = schema_scope) +# Defined datatype ifcintegercountratemeasure +class ifcintegercountratemeasure(INTEGER): + def __init__(self,*kargs): + pass + +# Defined datatype ifcaddresstypeenum +class ifcaddresstypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcbenchmarkenum +class ifcbenchmarkenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcoccupanttypeenum +class ifcoccupanttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmassdensitymeasure +class ifcmassdensitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccablecarriersegmenttypeenum +class ifccablecarriersegmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifclightdistributiondatasourceselect +ifclightdistributiondatasourceselect = SELECT( + 'ifcexternalreference', + 'ifclightintensitydistribution', + scope = schema_scope) +# SELECT TYPE ifcunit +ifcunit = SELECT( + 'ifcderivedunit', + 'ifcmonetaryunit', + 'ifcnamedunit', + scope = schema_scope) +# Defined datatype ifcmodulusofelasticitymeasure +class ifcmodulusofelasticitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcgridtypeenum +class ifcgridtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcstructuralcurveactivitytypeenum +class ifcstructuralcurveactivitytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcairterminaltypeenum +class ifcairterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcpointorvertexpoint +ifcpointorvertexpoint = SELECT( + 'ifcpoint', + 'ifcvertexpoint', + scope = schema_scope) +# Defined datatype ifcstructuralsurfaceactivitytypeenum +class ifcstructuralsurfaceactivitytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctransportelementtypeenum +class ifctransportelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelementassemblytypeenum +class ifcelementassemblytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdayinweeknumber +class ifcdayinweeknumber(INTEGER): + def __init__(self,*kargs): + pass + self.validrange() + + def validrange(self): + eval_validrange_wr = ((1 <= self) and (self <= 7)) + if not eval_validrange_wr: + raise AssertionError('Rule validrange violated') + else: + return eval_validrange_wr + +# Defined datatype ifcdocumentstatusenum +class ifcdocumentstatusenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcinterceptortypeenum +class ifcinterceptortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccurvefontorscaledcurvefontselect +ifccurvefontorscaledcurvefontselect = SELECT( + 'ifccurvestylefontandscaling', + 'ifccurvestylefontselect', + scope = schema_scope) +# Defined datatype ifcspecularexponent +class ifcspecularexponent(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifctextfontselect +ifctextfontselect = SELECT( + 'ifcexternallydefinedtextfont', + 'ifcpredefinedtextfont', + scope = schema_scope) +# Defined datatype ifcactiontypeenum +class ifcactiontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdynamicviscositymeasure +class ifcdynamicviscositymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclightemissionsourceenum +class ifclightemissionsourceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvolumemeasure +class ifcvolumemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcnullstyle +class ifcnullstyle(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcluminousintensitymeasure +class ifcluminousintensitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmodulusofrotationalsubgradereactionmeasure +class ifcmodulusofrotationalsubgradereactionmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcbuildingelementparttypeenum +class ifcbuildingelementparttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcspaceheatertypeenum +class ifcspaceheatertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmechanicalfastenertypeenum +class ifcmechanicalfastenertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpermittypeenum +class ifcpermittypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpiletypeenum +class ifcpiletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcstackterminaltypeenum +class ifcstackterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfiltertypeenum +class ifcfiltertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricdistributionboardtypeenum +class ifcelectricdistributionboardtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcabsorbeddosemeasure +class ifcabsorbeddosemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclightdistributioncurveenum +class ifclightdistributioncurveenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcmetricvalueselect +ifcmetricvalueselect = SELECT( + 'ifcappliedvalue', + 'ifcmeasurewithunit', + 'ifcreference', + 'ifctable', + 'ifctimeseries', + 'ifcvalue', + scope = schema_scope) +# Defined datatype ifcstructuralcurvemembertypeenum +class ifcstructuralcurvemembertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcobjecttypeenum +class ifcobjecttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcgridplacementdirectionselect +ifcgridplacementdirectionselect = SELECT( + 'ifcdirection', + 'ifcvirtualgridintersection', + scope = schema_scope) +# Defined datatype ifcfantypeenum +class ifcfantypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcgeometricprojectionenum +class ifcgeometricprojectionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcconstructionequipmentresourcetypeenum +class ifcconstructionequipmentresourcetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctrimmingpreference +class ifctrimmingpreference(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcinternalorexternalenum +class ifcinternalorexternalenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcproductrepresentationselect +ifcproductrepresentationselect = SELECT( + 'ifcproductdefinitionshape', + 'ifcrepresentationmap', + scope = schema_scope) +# Defined datatype ifcthermodynamictemperaturemeasure +class ifcthermodynamictemperaturemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsurfaceside +class ifcsurfaceside(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcenginetypeenum +class ifcenginetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricvoltagemeasure +class ifcelectricvoltagemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowstyleconstructionenum +class ifcwindowstyleconstructionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcductfittingtypeenum +class ifcductfittingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctubebundletypeenum +class ifctubebundletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccountmeasure +class ifccountmeasure(NUMBER): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrailingtypeenum +class ifcrailingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcswitchingdevicetypeenum +class ifcswitchingdevicetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcaccelerationmeasure +class ifcaccelerationmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccurvaturemeasure +class ifccurvaturemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcplaneanglemeasure +class ifcplaneanglemeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsurfaceorfacesurface +ifcsurfaceorfacesurface = SELECT( + 'ifcfacebasedsurfacemodel', + 'ifcfacesurface', + 'ifcsurface', + scope = schema_scope) +# Defined datatype ifclogicaloperatorenum +class ifclogicaloperatorenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcshadingdevicetypeenum +class ifcshadingdevicetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcmeasurevalue +ifcmeasurevalue = SELECT( + 'ifcamountofsubstancemeasure', + 'ifcareameasure', + 'ifccomplexnumber', + 'ifccontextdependentmeasure', + 'ifccountmeasure', + 'ifcdescriptivemeasure', + 'ifcelectriccurrentmeasure', + 'ifclengthmeasure', + 'ifcluminousintensitymeasure', + 'ifcmassmeasure', + 'ifcnonnegativelengthmeasure', + 'ifcnormalisedratiomeasure', + 'ifcnumericmeasure', + 'ifcparametervalue', + 'ifcplaneanglemeasure', + 'ifcpositivelengthmeasure', + 'ifcpositiveplaneanglemeasure', + 'ifcpositiveratiomeasure', + 'ifcratiomeasure', + 'ifcsolidanglemeasure', + 'ifcthermodynamictemperaturemeasure', + 'ifctimemeasure', + 'ifcvolumemeasure', + scope = schema_scope) +# SELECT TYPE ifclibraryselect +ifclibraryselect = SELECT( + 'ifclibraryinformation', + 'ifclibraryreference', + scope = schema_scope) +# Defined datatype ifcparametervalue +class ifcparametervalue(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcthermalconductivitymeasure +class ifcthermalconductivitymeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccoordinatereferencesystemselect +ifccoordinatereferencesystemselect = SELECT( + 'ifccoordinatereferencesystem', + 'ifcgeometricrepresentationcontext', + scope = schema_scope) +# Defined datatype ifcsectiontypeenum +class ifcsectiontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcplanarforcemeasure +class ifcplanarforcemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcprojectionelementtypeenum +class ifcprojectionelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcgeometricsetselect +ifcgeometricsetselect = SELECT( + 'ifccurve', + 'ifcpoint', + 'ifcsurface', + scope = schema_scope) +# Defined datatype ifctaskdurationenum +class ifctaskdurationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcdefinitionselect +ifcdefinitionselect = SELECT( + 'ifcobjectdefinition', + 'ifcpropertydefinition', + scope = schema_scope) +# Defined datatype ifcmedicaldevicetypeenum +class ifcmedicaldevicetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcareameasure +class ifcareameasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccontextdependentmeasure +class ifccontextdependentmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctextfontname +class ifctextfontname(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifclogical +class ifclogical(LOGICAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcthermaladmittancemeasure +class ifcthermaladmittancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcspacetypeenum +class ifcspacetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoseequivalentmeasure +class ifcdoseequivalentmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcareadensitymeasure +class ifcareadensitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmolecularweightmeasure +class ifcmolecularweightmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccommunicationsappliancetypeenum +class ifccommunicationsappliancetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcobjectreferenceselect +ifcobjectreferenceselect = SELECT( + 'ifcaddress', + 'ifcappliedvalue', + 'ifcexternalreference', + 'ifcmaterialdefinition', + 'ifcorganization', + 'ifcperson', + 'ifcpersonandorganization', + 'ifctable', + 'ifctimeseries', + scope = schema_scope) +# Defined datatype ifcpowermeasure +class ifcpowermeasure(REAL): + def __init__(self,*kargs): + pass + +ifcpropertysetdefinitionset = SET(1,None,'ifcpropertysetdefinition', scope = schema_scope) +# Defined datatype ifceventtriggertypeenum +class ifceventtriggertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccurveoredgecurve +ifccurveoredgecurve = SELECT( + 'ifcboundedcurve', + 'ifcedgecurve', + scope = schema_scope) +# SELECT TYPE ifcmodulusofrotationalsubgradereactionselect +ifcmodulusofrotationalsubgradereactionselect = SELECT( + 'ifcboolean', + 'ifcmodulusofrotationalsubgradereactionmeasure', + scope = schema_scope) +# Defined datatype ifccoveringtypeenum +class ifccoveringtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcopeningelementtypeenum +class ifcopeningelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcunitaryequipmenttypeenum +class ifcunitaryequipmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcaxis2placement +ifcaxis2placement = SELECT( + 'ifcaxis2placement2d', + 'ifcaxis2placement3d', + scope = schema_scope) +# Defined datatype ifcbooleanoperator +class ifcbooleanoperator(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccostscheduletypeenum +class ifccostscheduletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcspatialzonetypeenum +class ifcspatialzonetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfastenertypeenum +class ifcfastenertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpileconstructionenum +class ifcpileconstructionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcderivedunitenum +class ifcderivedunitenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricflowstoragedevicetypeenum +class ifcelectricflowstoragedevicetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcexternalspatialelementtypeenum +class ifcexternalspatialelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclightfixturetypeenum +class ifclightfixturetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfontstyle +class ifcfontstyle(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['normal','italic','oblique']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifctime +class ifctime(STRING): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifctrimmingselect +ifctrimmingselect = SELECT( + 'ifccartesianpoint', + 'ifcparametervalue', + scope = schema_scope) +# Defined datatype ifcamountofsubstancemeasure +class ifcamountofsubstancemeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsizeselect +ifcsizeselect = SELECT( + 'ifcdescriptivemeasure', + 'ifclengthmeasure', + 'ifcnormalisedratiomeasure', + 'ifcpositivelengthmeasure', + 'ifcpositiveratiomeasure', + 'ifcratiomeasure', + scope = schema_scope) +# Defined datatype ifcbeamtypeenum +class ifcbeamtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcnonnegativelengthmeasure +class ifcnonnegativelengthmeasure(ifclengthmeasure): + def __init__(self,*kargs): + pass + self.notnegative() + + def notnegative(self): + eval_notnegative_wr = (self >= 0) + if not eval_notnegative_wr: + raise AssertionError('Rule notnegative violated') + else: + return eval_notnegative_wr + +# Defined datatype ifcpumptypeenum +class ifcpumptypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcboxalignment +class ifcboxalignment(ifclabel): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['top-left','top-middle','top-right','middle-left','center','middle-right','bottom-left','bottom-middle','bottom-right']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcelectricchargemeasure +class ifcelectricchargemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcinventorytypeenum +class ifcinventorytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowtypepartitioningenum +class ifcwindowtypepartitioningenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwarpingmomentmeasure +class ifcwarpingmomentmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctext +class ifctext(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcairterminalboxtypeenum +class ifcairterminalboxtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcderivedmeasurevalue +ifcderivedmeasurevalue = SELECT( + 'ifcabsorbeddosemeasure', + 'ifcaccelerationmeasure', + 'ifcangularvelocitymeasure', + 'ifcareadensitymeasure', + 'ifccompoundplaneanglemeasure', + 'ifccurvaturemeasure', + 'ifcdoseequivalentmeasure', + 'ifcdynamicviscositymeasure', + 'ifcelectriccapacitancemeasure', + 'ifcelectricchargemeasure', + 'ifcelectricconductancemeasure', + 'ifcelectricresistancemeasure', + 'ifcelectricvoltagemeasure', + 'ifcenergymeasure', + 'ifcforcemeasure', + 'ifcfrequencymeasure', + 'ifcheatfluxdensitymeasure', + 'ifcheatingvaluemeasure', + 'ifcilluminancemeasure', + 'ifcinductancemeasure', + 'ifcintegercountratemeasure', + 'ifcionconcentrationmeasure', + 'ifcisothermalmoisturecapacitymeasure', + 'ifckinematicviscositymeasure', + 'ifclinearforcemeasure', + 'ifclinearmomentmeasure', + 'ifclinearstiffnessmeasure', + 'ifclinearvelocitymeasure', + 'ifcluminousfluxmeasure', + 'ifcluminousintensitydistributionmeasure', + 'ifcmagneticfluxdensitymeasure', + 'ifcmagneticfluxmeasure', + 'ifcmassdensitymeasure', + 'ifcmassflowratemeasure', + 'ifcmassperlengthmeasure', + 'ifcmodulusofelasticitymeasure', + 'ifcmodulusoflinearsubgradereactionmeasure', + 'ifcmodulusofrotationalsubgradereactionmeasure', + 'ifcmodulusofsubgradereactionmeasure', + 'ifcmoisturediffusivitymeasure', + 'ifcmolecularweightmeasure', + 'ifcmomentofinertiameasure', + 'ifcmonetarymeasure', + 'ifcphmeasure', + 'ifcplanarforcemeasure', + 'ifcpowermeasure', + 'ifcpressuremeasure', + 'ifcradioactivitymeasure', + 'ifcrotationalfrequencymeasure', + 'ifcrotationalmassmeasure', + 'ifcrotationalstiffnessmeasure', + 'ifcsectionmodulusmeasure', + 'ifcsectionalareaintegralmeasure', + 'ifcshearmodulusmeasure', + 'ifcsoundpowerlevelmeasure', + 'ifcsoundpowermeasure', + 'ifcsoundpressurelevelmeasure', + 'ifcsoundpressuremeasure', + 'ifcspecificheatcapacitymeasure', + 'ifctemperaturegradientmeasure', + 'ifctemperaturerateofchangemeasure', + 'ifcthermaladmittancemeasure', + 'ifcthermalconductivitymeasure', + 'ifcthermalexpansioncoefficientmeasure', + 'ifcthermalresistancemeasure', + 'ifcthermaltransmittancemeasure', + 'ifctorquemeasure', + 'ifcvaporpermeabilitymeasure', + 'ifcvolumetricflowratemeasure', + 'ifcwarpingconstantmeasure', + 'ifcwarpingmomentmeasure', + scope = schema_scope) +# Defined datatype ifcgeographicelementtypeenum +class ifcgeographicelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcreinforcingbarroleenum +class ifcreinforcingbarroleenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclinearstiffnessmeasure +class ifclinearstiffnessmeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccolourorfactor +ifccolourorfactor = SELECT( + 'ifccolourrgb', + 'ifcnormalisedratiomeasure', + scope = schema_scope) +# SELECT TYPE ifcvectorordirection +ifcvectorordirection = SELECT( + 'ifcdirection', + 'ifcvector', + scope = schema_scope) +# Defined datatype ifcisothermalmoisturecapacitymeasure +class ifcisothermalmoisturecapacitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricappliancetypeenum +class ifcelectricappliancetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcworkplantypeenum +class ifcworkplantypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcratiomeasure +class ifcratiomeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfootingtypeenum +class ifcfootingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfurnituretypeenum +class ifcfurnituretypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcresourceselect +ifcresourceselect = SELECT( + 'ifcresource', + 'ifctyperesource', + scope = schema_scope) +# Defined datatype ifcplatetypeenum +class ifcplatetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsimplevalue +ifcsimplevalue = SELECT( + 'ifcboolean', + 'ifcdate', + 'ifcdatetime', + 'ifcduration', + 'ifcidentifier', + 'ifcinteger', + 'ifclabel', + 'ifclogical', + 'ifcreal', + 'ifctext', + 'ifctime', + 'ifctimestamp', + scope = schema_scope) +# Defined datatype ifcinteger +class ifcinteger(INTEGER): + def __init__(self,*kargs): + pass + +# Defined datatype ifcthermalexpansioncoefficientmeasure +class ifcthermalexpansioncoefficientmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctendonanchortypeenum +class ifctendonanchortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpositiveplaneanglemeasure +class ifcpositiveplaneanglemeasure(ifcplaneanglemeasure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifccooledbeamtypeenum +class ifccooledbeamtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdimensioncount +class ifcdimensioncount(INTEGER): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 < self) and (self <= 3)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcmassmeasure +class ifcmassmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdataoriginenum +class ifcdataoriginenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcphysicalorvirtualenum +class ifcphysicalorvirtualenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpermeablecoveringoperationenum +class ifcpermeablecoveringoperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcstairflighttypeenum +class ifcstairflighttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcjunctionboxtypeenum +class ifcjunctionboxtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifctranslationalstiffnessselect +ifctranslationalstiffnessselect = SELECT( + 'ifcboolean', + 'ifclinearstiffnessmeasure', + scope = schema_scope) +# Defined datatype ifctorquemeasure +class ifctorquemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcglobalorlocalenum +class ifcglobalorlocalenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmoisturediffusivitymeasure +class ifcmoisturediffusivitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdistributionchamberelementtypeenum +class ifcdistributionchamberelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcduration +class ifcduration(STRING): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcspaceboundaryselect +ifcspaceboundaryselect = SELECT( + 'ifcexternalspatialelement', + 'ifcspace', + scope = schema_scope) +# Defined datatype ifctextpath +class ifctextpath(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcunitenum +class ifcunitenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvalvetypeenum +class ifcvalvetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpresentabletext +class ifcpresentabletext(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifccompressortypeenum +class ifccompressortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctimeseriesdatatypeenum +class ifctimeseriesdatatypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcspecularhighlightselect +ifcspecularhighlightselect = SELECT( + 'ifcspecularexponent', + 'ifcspecularroughness', + scope = schema_scope) +# Defined datatype ifcdayinmonthnumber +class ifcdayinmonthnumber(INTEGER): + def __init__(self,*kargs): + pass + self.validrange() + + def validrange(self): + eval_validrange_wr = ((1 <= self) and (self <= 31)) + if not eval_validrange_wr: + raise AssertionError('Rule validrange violated') + else: + return eval_validrange_wr + +# Defined datatype ifcconstructionmaterialresourcetypeenum +class ifcconstructionmaterialresourcetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcspecificheatcapacitymeasure +class ifcspecificheatcapacitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcenergymeasure +class ifcenergymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectriccurrentmeasure +class ifcelectriccurrentmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcburnertypeenum +class ifcburnertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifclayereditem +ifclayereditem = SELECT( + 'ifcrepresentation', + 'ifcrepresentationitem', + scope = schema_scope) +# Defined datatype ifcluminousfluxmeasure +class ifcluminousfluxmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsensortypeenum +class ifcsensortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsequenceenum +class ifcsequenceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdescriptivemeasure +class ifcdescriptivemeasure(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelementcompositionenum +class ifcelementcompositionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcmodulusofsubgradereactionselect +ifcmodulusofsubgradereactionselect = SELECT( + 'ifcboolean', + 'ifcmodulusofsubgradereactionmeasure', + scope = schema_scope) +# Defined datatype ifcthermaltransmittancemeasure +class ifcthermaltransmittancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcreinforcingmeshtypeenum +class ifcreinforcingmeshtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcreal +class ifcreal(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcconstraintenum +class ifcconstraintenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoorpanelpositionenum +class ifcdoorpanelpositionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcflowdirectionenum +class ifcflowdirectionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcbsplinesurfaceform +class ifcbsplinesurfaceform(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsiprefix +class ifcsiprefix(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcboilertypeenum +class ifcboilertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmagneticfluxdensitymeasure +class ifcmagneticfluxdensitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccoolingtowertypeenum +class ifccoolingtowertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcboolean +class ifcboolean(BOOLEAN): + def __init__(self,*kargs): + pass + +# Defined datatype ifcbuildingelementproxytypeenum +class ifcbuildingelementproxytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcangularvelocitymeasure +class ifcangularvelocitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmonetarymeasure +class ifcmonetarymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmonthinyearnumber +class ifcmonthinyearnumber(INTEGER): + def __init__(self,*kargs): + pass + self.validrange() + + def validrange(self): + eval_validrange_wr = ((1 <= self) and (self <= 12)) + if not eval_validrange_wr: + raise AssertionError('Rule validrange violated') + else: + return eval_validrange_wr + +# Defined datatype ifcsectionmodulusmeasure +class ifcsectionmodulusmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdistributionsystemenum +class ifcdistributionsystemenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoorstyleconstructionenum +class ifcdoorstyleconstructionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifceventtypeenum +class ifceventtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrooftypeenum +class ifcrooftypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsanitaryterminaltypeenum +class ifcsanitaryterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdocumentconfidentialityenum +class ifcdocumentconfidentialityenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfiresuppressionterminaltypeenum +class ifcfiresuppressionterminaltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsubcontractresourcetypeenum +class ifcsubcontractresourcetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcpropertysetdefinitionselect +ifcpropertysetdefinitionselect = SELECT( + 'ifcpropertysetdefinition', + 'ifcpropertysetdefinitionset', + scope = schema_scope) +# Defined datatype ifcradioactivitymeasure +class ifcradioactivitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmomentofinertiameasure +class ifcmomentofinertiameasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifclaborresourcetypeenum +class ifclaborresourcetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwarpingconstantmeasure +class ifcwarpingconstantmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcknottype +class ifcknottype(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcheatfluxdensitymeasure +class ifcheatfluxdensitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcurireference +class ifcurireference(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcbuildingsystemtypeenum +class ifcbuildingsystemtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowtypeenum +class ifcwindowtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvaporpermeabilitymeasure +class ifcvaporpermeabilitymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsolardevicetypeenum +class ifcsolardevicetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvibrationisolatortypeenum +class ifcvibrationisolatortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcbooleanoperand +ifcbooleanoperand = SELECT( + 'ifcbooleanresult', + 'ifccsgprimitive3d', + 'ifchalfspacesolid', + 'ifcsolidmodel', + scope = schema_scope) +# Defined datatype ifcflowinstrumenttypeenum +class ifcflowinstrumenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfontvariant +class ifcfontvariant(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['normal','small-caps']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifccostitemtypeenum +class ifccostitemtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcprofiletypeenum +class ifcprofiletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcactorselect +ifcactorselect = SELECT( + 'ifcorganization', + 'ifcperson', + 'ifcpersonandorganization', + scope = schema_scope) +# Defined datatype ifcmagneticfluxmeasure +class ifcmagneticfluxmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifccomplexpropertytemplatetypeenum +class ifccomplexpropertytemplatetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcworkscheduletypeenum +class ifcworkscheduletypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcgloballyuniqueid +class ifcgloballyuniqueid(STRING): + def __init__(self,*kargs): + pass + +# Defined datatype ifcevaporativecoolertypeenum +class ifcevaporativecoolertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcprotectivedevicetrippingunittypeenum +class ifcprotectivedevicetrippingunittypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcfontweight +class ifcfontweight(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['normal','small-caps','100','200','300','400','500','600','700','800','900']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcchillertypeenum +class ifcchillertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoortypeenum +class ifcdoortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcalarmtypeenum +class ifcalarmtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccablecarrierfittingtypeenum +class ifccablecarrierfittingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifctasktypeenum +class ifctasktypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifctimeorratioselect +ifctimeorratioselect = SELECT( + 'ifcduration', + 'ifcratiomeasure', + scope = schema_scope) +# SELECT TYPE ifcwarpingstiffnessselect +ifcwarpingstiffnessselect = SELECT( + 'ifcboolean', + 'ifcwarpingmomentmeasure', + scope = schema_scope) +# Defined datatype ifccolumntypeenum +class ifccolumntypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcperformancehistorytypeenum +class ifcperformancehistorytypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcprojectordertypeenum +class ifcprojectordertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcramptypeenum +class ifcramptypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcstateenum +class ifcstateenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpipesegmenttypeenum +class ifcpipesegmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcnormalisedratiomeasure +class ifcnormalisedratiomeasure(ifcratiomeasure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = ((0 <= self) and (self <= 1)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcreinforcingbarsurfaceenum +class ifcreinforcingbarsurfaceenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpositivelengthmeasure +class ifcpositivelengthmeasure(ifclengthmeasure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcdampertypeenum +class ifcdampertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifclayersetdirectionenum +class ifclayersetdirectionenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpropertysettemplatetypeenum +class ifcpropertysettemplatetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcaudiovisualappliancetypeenum +class ifcaudiovisualappliancetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpipefittingtypeenum +class ifcpipefittingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifccurvestylefontselect +ifccurvestylefontselect = SELECT( + 'ifccurvestylefont', + 'ifcpredefinedcurvefont', + scope = schema_scope) +# Defined datatype ifcstairtypeenum +class ifcstairtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +ifccomplexnumber = ARRAY(1,2,'REAL', scope = schema_scope) +ifccompoundplaneanglemeasure = LIST(3,4,'INTEGER', scope = schema_scope) +# Defined datatype ifcevaporatortypeenum +class ifcevaporatortypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmembertypeenum +class ifcmembertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcbendingparameterselect +ifcbendingparameterselect = SELECT( + 'ifclengthmeasure', + 'ifcplaneanglemeasure', + scope = schema_scope) +# Defined datatype ifcflowmetertypeenum +class ifcflowmetertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcprojectedortruelengthenum +class ifcprojectedortruelengthenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcpositiveratiomeasure +class ifcpositiveratiomeasure(ifcratiomeasure): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self > 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifcobjectiveenum +class ifcobjectiveenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcrotationalstiffnessselect +ifcrotationalstiffnessselect = SELECT( + 'ifcboolean', + 'ifcrotationalstiffnessmeasure', + scope = schema_scope) +# Defined datatype ifcrotationalfrequencymeasure +class ifcrotationalfrequencymeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcvolumetricflowratemeasure +class ifcvolumetricflowratemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcunitarycontrolelementtypeenum +class ifcunitarycontrolelementtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcwindowstyleoperationenum +class ifcwindowstyleoperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcclassificationselect +ifcclassificationselect = SELECT( + 'ifcclassification', + 'ifcclassificationreference', + scope = schema_scope) +# Defined datatype ifclinearmomentmeasure +class ifclinearmomentmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcphmeasure +class ifcphmeasure(REAL): + def __init__(self,*kargs): + pass + self.wr21() + + def wr21(self): + eval_wr21_wr = ((0 <= self) and (self <= 14)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + +# Defined datatype ifccondensertypeenum +class ifccondensertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcproductselect +ifcproductselect = SELECT( + 'ifcproduct', + 'ifctypeproduct', + scope = schema_scope) +# Defined datatype ifcmotorconnectiontypeenum +class ifcmotorconnectiontypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsimplepropertytemplatetypeenum +class ifcsimplepropertytemplatetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcprocessselect +ifcprocessselect = SELECT( + 'ifcprocess', + 'ifctypeprocess', + scope = schema_scope) +# Defined datatype ifcmodulusofsubgradereactionmeasure +class ifcmodulusofsubgradereactionmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsolidanglemeasure +class ifcsolidanglemeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcmodulusoftranslationalsubgradereactionselect +ifcmodulusoftranslationalsubgradereactionselect = SELECT( + 'ifcboolean', + 'ifcmodulusoflinearsubgradereactionmeasure', + scope = schema_scope) +# Defined datatype ifcwalltypeenum +class ifcwalltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcdocumentselect +ifcdocumentselect = SELECT( + 'ifcdocumentinformation', + 'ifcdocumentreference', + scope = schema_scope) +# Defined datatype ifcdoorstyleoperationenum +class ifcdoorstyleoperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcductsegmenttypeenum +class ifcductsegmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcionconcentrationmeasure +class ifcionconcentrationmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcnumericmeasure +class ifcnumericmeasure(NUMBER): + def __init__(self,*kargs): + pass + +# Defined datatype ifccablefittingtypeenum +class ifccablefittingtypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcmassflowratemeasure +class ifcmassflowratemeasure(REAL): + def __init__(self,*kargs): + pass + +# SELECT TYPE ifcsurfacestyleelementselect +ifcsurfacestyleelementselect = SELECT( + 'ifcexternallydefinedsurfacestyle', + 'ifcsurfacestylelighting', + 'ifcsurfacestylerefraction', + 'ifcsurfacestyleshading', + 'ifcsurfacestylewithtextures', + scope = schema_scope) +# Defined datatype ifcreinforcingbartypeenum +class ifcreinforcingbartypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcconstructionproductresourcetypeenum +class ifcconstructionproductresourcetypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifccurveinterpolationenum +class ifccurveinterpolationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcoutlettypeenum +class ifcoutlettypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcsoundpowerlevelmeasure +class ifcsoundpowerlevelmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctemperaturegradientmeasure +class ifctemperaturegradientmeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifctextdecoration +class ifctextdecoration(STRING): + def __init__(self,*kargs): + pass + self.wr1() + + def wr1(self): + eval_wr1_wr = (self == ['none','underline','overline','line-through','blink']) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + +# Defined datatype ifctimestamp +class ifctimestamp(INTEGER): + def __init__(self,*kargs): + pass + +# Defined datatype ifccablesegmenttypeenum +class ifccablesegmenttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcdoortypeoperationenum +class ifcdoortypeoperationenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcarithmeticoperatorenum +class ifcarithmeticoperatorenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcworkcalendartypeenum +class ifcworkcalendartypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcstructuralsurfacemembertypeenum +class ifcstructuralsurfacemembertypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectricresistancemeasure +class ifcelectricresistancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcilluminancemeasure +class ifcilluminancemeasure(REAL): + def __init__(self,*kargs): + pass + +# Defined datatype ifcrampflighttypeenum +class ifcrampflighttypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcbsplinecurveform +class ifcbsplinecurveform(ENUMERATION): + def __init__(self,*kargs): + pass + +# Defined datatype ifcelectrictimecontroltypeenum +class ifcelectrictimecontroltypeenum(ENUMERATION): + def __init__(self,*kargs): + pass + + +#################### + # ENTITY ifcroot # +#################### +class ifcroot(BaseEntityClass): + '''Entity ifcroot definition. + + :param globalid + :type globalid:ifcgloballyuniqueid + + :param ownerhistory + :type ownerhistory:ifcownerhistory + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + ''' + def __init__( self , globalid,ownerhistory,name,description, ): + self.globalid = globalid + self.ownerhistory = ownerhistory + self.name = name + self.description = description + + @apply + def globalid(): + def fget( self ): + return self._globalid + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument globalid is mantatory and can not be set to None') + if not check_type(value,ifcgloballyuniqueid): + self._globalid = ifcgloballyuniqueid(value) + else: + self._globalid = value + return property(**locals()) + + @apply + def ownerhistory(): + def fget( self ): + return self._ownerhistory + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcownerhistory): + self._ownerhistory = ifcownerhistory(value) + else: + self._ownerhistory = value + else: + self._ownerhistory = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY ifcrelationship # +#################### +class ifcrelationship(ifcroot): + '''Entity ifcrelationship definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcroot.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + +#################### + # ENTITY ifcrelconnects # +#################### +class ifcrelconnects(ifcrelationship): + '''Entity ifcrelconnects definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + +#################### + # ENTITY ifcrelspaceboundary # +#################### +class ifcrelspaceboundary(ifcrelconnects): + '''Entity ifcrelspaceboundary definition. + + :param relatingspace + :type relatingspace:ifcspaceboundaryselect + + :param relatedbuildingelement + :type relatedbuildingelement:ifcelement + + :param connectiongeometry + :type connectiongeometry:ifcconnectiongeometry + + :param physicalorvirtualboundary + :type physicalorvirtualboundary:ifcphysicalorvirtualenum + + :param internalorexternalboundary + :type internalorexternalboundary:ifcinternalorexternalenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingspace,relatedbuildingelement,connectiongeometry,physicalorvirtualboundary,internalorexternalboundary, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingspace = relatingspace + self.relatedbuildingelement = relatedbuildingelement + self.connectiongeometry = connectiongeometry + self.physicalorvirtualboundary = physicalorvirtualboundary + self.internalorexternalboundary = internalorexternalboundary + + @apply + def relatingspace(): + def fget( self ): + return self._relatingspace + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingspace is mantatory and can not be set to None') + if not check_type(value,ifcspaceboundaryselect): + self._relatingspace = ifcspaceboundaryselect(value) + else: + self._relatingspace = value + return property(**locals()) + + @apply + def relatedbuildingelement(): + def fget( self ): + return self._relatedbuildingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedbuildingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatedbuildingelement = ifcelement(value) + else: + self._relatedbuildingelement = value + return property(**locals()) + + @apply + def connectiongeometry(): + def fget( self ): + return self._connectiongeometry + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcconnectiongeometry): + self._connectiongeometry = ifcconnectiongeometry(value) + else: + self._connectiongeometry = value + else: + self._connectiongeometry = value + return property(**locals()) + + @apply + def physicalorvirtualboundary(): + def fget( self ): + return self._physicalorvirtualboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument physicalorvirtualboundary is mantatory and can not be set to None') + if not check_type(value,ifcphysicalorvirtualenum): + self._physicalorvirtualboundary = ifcphysicalorvirtualenum(value) + else: + self._physicalorvirtualboundary = value + return property(**locals()) + + @apply + def internalorexternalboundary(): + def fget( self ): + return self._internalorexternalboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument internalorexternalboundary is mantatory and can not be set to None') + if not check_type(value,ifcinternalorexternalenum): + self._internalorexternalboundary = ifcinternalorexternalenum(value) + else: + self._internalorexternalboundary = value + return property(**locals()) + def correctphysorvirt(self): + eval_correctphysorvirt_wr = ((((self.physicalorvirtualboundary == ifcphysicalorvirtualenum.self.physical) and ( not ('IFC4.IFCVIRTUALELEMENT' == TYPEOF(self.relatedbuildingelement)))) or ((self.physicalorvirtualboundary == ifcphysicalorvirtualenum.self.virtual) and (('IFC4.IFCVIRTUALELEMENT' == TYPEOF(self.relatedbuildingelement)) or ('IFC4.IFCOPENINGELEMENT' == TYPEOF(self.relatedbuildingelement))))) or (self.physicalorvirtualboundary == ifcphysicalorvirtualenum.self.notdefined)) + if not eval_correctphysorvirt_wr: + raise AssertionError('Rule correctphysorvirt violated') + else: + return eval_correctphysorvirt_wr + + +#################### + # ENTITY ifcrelspaceboundary1stlevel # +#################### +class ifcrelspaceboundary1stlevel(ifcrelspaceboundary): + '''Entity ifcrelspaceboundary1stlevel definition. + + :param parentboundary + :type parentboundary:ifcrelspaceboundary1stlevel + + :param innerboundaries + :type innerboundaries:SET(0,None,'ifcrelspaceboundary1stlevel', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingspace , inherited5__relatedbuildingelement , inherited6__connectiongeometry , inherited7__physicalorvirtualboundary , inherited8__internalorexternalboundary , parentboundary, ): + ifcrelspaceboundary.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingspace , inherited5__relatedbuildingelement , inherited6__connectiongeometry , inherited7__physicalorvirtualboundary , inherited8__internalorexternalboundary , ) + self.parentboundary = parentboundary + + @apply + def parentboundary(): + def fget( self ): + return self._parentboundary + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrelspaceboundary1stlevel): + self._parentboundary = ifcrelspaceboundary1stlevel(value) + else: + self._parentboundary = value + else: + self._parentboundary = value + return property(**locals()) + + @apply + def innerboundaries(): + def fget( self ): + return self._innerboundaries + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument innerboundaries is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcrelspaceboundary2ndlevel # +#################### +class ifcrelspaceboundary2ndlevel(ifcrelspaceboundary1stlevel): + '''Entity ifcrelspaceboundary2ndlevel definition. + + :param correspondingboundary + :type correspondingboundary:ifcrelspaceboundary2ndlevel + + :param corresponds + :type corresponds:SET(0,1,'ifcrelspaceboundary2ndlevel', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingspace , inherited5__relatedbuildingelement , inherited6__connectiongeometry , inherited7__physicalorvirtualboundary , inherited8__internalorexternalboundary , inherited9__parentboundary , correspondingboundary, ): + ifcrelspaceboundary1stlevel.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingspace , inherited5__relatedbuildingelement , inherited6__connectiongeometry , inherited7__physicalorvirtualboundary , inherited8__internalorexternalboundary , inherited9__parentboundary , ) + self.correspondingboundary = correspondingboundary + + @apply + def correspondingboundary(): + def fget( self ): + return self._correspondingboundary + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrelspaceboundary2ndlevel): + self._correspondingboundary = ifcrelspaceboundary2ndlevel(value) + else: + self._correspondingboundary = value + else: + self._correspondingboundary = value + return property(**locals()) + + @apply + def corresponds(): + def fget( self ): + return self._corresponds + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument corresponds is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcobjectdefinition # +#################### +class ifcobjectdefinition(ifcroot): + '''Entity ifcobjectdefinition definition. + + :param hasassignments + :type hasassignments:SET(0,None,'ifcrelassigns', scope = schema_scope) + + :param nests + :type nests:SET(0,1,'ifcrelnests', scope = schema_scope) + + :param isnestedby + :type isnestedby:SET(0,None,'ifcrelnests', scope = schema_scope) + + :param hascontext + :type hascontext:SET(0,1,'ifcreldeclares', scope = schema_scope) + + :param isdecomposedby + :type isdecomposedby:SET(0,None,'ifcrelaggregates', scope = schema_scope) + + :param decomposes + :type decomposes:SET(0,1,'ifcrelaggregates', scope = schema_scope) + + :param hasassociations + :type hasassociations:SET(0,None,'ifcrelassociates', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcroot.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + + @apply + def hasassignments(): + def fget( self ): + return self._hasassignments + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasassignments is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def nests(): + def fget( self ): + return self._nests + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument nests is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isnestedby(): + def fget( self ): + return self._isnestedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isnestedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hascontext(): + def fget( self ): + return self._hascontext + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hascontext is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isdecomposedby(): + def fget( self ): + return self._isdecomposedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isdecomposedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def decomposes(): + def fget( self ): + return self._decomposes + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument decomposes is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasassociations(): + def fget( self ): + return self._hasassociations + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasassociations is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcobject # +#################### +class ifcobject(ifcobjectdefinition): + '''Entity ifcobject definition. + + :param objecttype + :type objecttype:ifclabel + + :param isdeclaredby + :type isdeclaredby:SET(0,1,'ifcreldefinesbyobject', scope = schema_scope) + + :param declares + :type declares:SET(0,None,'ifcreldefinesbyobject', scope = schema_scope) + + :param istypedby + :type istypedby:SET(0,1,'ifcreldefinesbytype', scope = schema_scope) + + :param isdefinedby + :type isdefinedby:SET(0,None,'ifcreldefinesbyproperties', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , objecttype, ): + ifcobjectdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.objecttype = objecttype + + @apply + def objecttype(): + def fget( self ): + return self._objecttype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._objecttype = ifclabel(value) + else: + self._objecttype = value + else: + self._objecttype = value + return property(**locals()) + + @apply + def isdeclaredby(): + def fget( self ): + return self._isdeclaredby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isdeclaredby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def declares(): + def fget( self ): + return self._declares + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument declares is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def istypedby(): + def fget( self ): + return self._istypedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument istypedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isdefinedby(): + def fget( self ): + return self._isdefinedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isdefinedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcproduct # +#################### +class ifcproduct(ifcobject): + '''Entity ifcproduct definition. + + :param objectplacement + :type objectplacement:ifcobjectplacement + + :param representation + :type representation:ifcproductrepresentation + + :param referencedby + :type referencedby:SET(0,None,'ifcrelassignstoproduct', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , objectplacement,representation, ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.objectplacement = objectplacement + self.representation = representation + + @apply + def objectplacement(): + def fget( self ): + return self._objectplacement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcobjectplacement): + self._objectplacement = ifcobjectplacement(value) + else: + self._objectplacement = value + else: + self._objectplacement = value + return property(**locals()) + + @apply + def representation(): + def fget( self ): + return self._representation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcproductrepresentation): + self._representation = ifcproductrepresentation(value) + else: + self._representation = value + else: + self._representation = value + return property(**locals()) + + @apply + def referencedby(): + def fget( self ): + return self._referencedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referencedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def placementforshaperepresentation(self): + eval_placementforshaperepresentation_wr = (((EXISTS(self.representation) and EXISTS(self.objectplacement)) or (EXISTS(self.representation) and (SIZEOF(None) == 0))) or ( not EXISTS(self.representation))) + if not eval_placementforshaperepresentation_wr: + raise AssertionError('Rule placementforshaperepresentation violated') + else: + return eval_placementforshaperepresentation_wr + + +#################### + # ENTITY ifcstructuralactivity # +#################### +class ifcstructuralactivity(ifcproduct): + '''Entity ifcstructuralactivity definition. + + :param appliedload + :type appliedload:ifcstructuralload + + :param globalorlocal + :type globalorlocal:ifcglobalorlocalenum + + :param assignedtostructuralitem + :type assignedtostructuralitem:SET(0,1,'ifcrelconnectsstructuralactivity', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , appliedload,globalorlocal, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.appliedload = appliedload + self.globalorlocal = globalorlocal + + @apply + def appliedload(): + def fget( self ): + return self._appliedload + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument appliedload is mantatory and can not be set to None') + if not check_type(value,ifcstructuralload): + self._appliedload = ifcstructuralload(value) + else: + self._appliedload = value + return property(**locals()) + + @apply + def globalorlocal(): + def fget( self ): + return self._globalorlocal + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument globalorlocal is mantatory and can not be set to None') + if not check_type(value,ifcglobalorlocalenum): + self._globalorlocal = ifcglobalorlocalenum(value) + else: + self._globalorlocal = value + return property(**locals()) + + @apply + def assignedtostructuralitem(): + def fget( self ): + return self._assignedtostructuralitem + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument assignedtostructuralitem is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructuralreaction # +#################### +class ifcstructuralreaction(ifcstructuralactivity): + '''Entity ifcstructuralreaction definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ): + ifcstructuralactivity.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ) + +#################### + # ENTITY ifcstructuralcurvereaction # +#################### +class ifcstructuralcurvereaction(ifcstructuralreaction): + '''Entity ifcstructuralcurvereaction definition. + + :param predefinedtype + :type predefinedtype:ifcstructuralcurveactivitytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , predefinedtype, ): + ifcstructuralreaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstructuralcurveactivitytypeenum): + self._predefinedtype = ifcstructuralcurveactivitytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def hasobjecttype(self): + eval_hasobjecttype_wr = ((self.predefinedtype != ifcstructuralcurveactivitytypeenum.self.userdefined) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + def suitablepredefinedtype(self): + eval_suitablepredefinedtype_wr = ((self.predefinedtype != ifcstructuralcurveactivitytypeenum.self.sinus) and (self.predefinedtype != ifcstructuralcurveactivitytypeenum.self.parabola)) + if not eval_suitablepredefinedtype_wr: + raise AssertionError('Rule suitablepredefinedtype violated') + else: + return eval_suitablepredefinedtype_wr + + +#################### + # ENTITY ifcelement # +#################### +class ifcelement(ifcproduct): + '''Entity ifcelement definition. + + :param tag + :type tag:ifcidentifier + + :param fillsvoids + :type fillsvoids:SET(0,1,'ifcrelfillselement', scope = schema_scope) + + :param connectedto + :type connectedto:SET(0,None,'ifcrelconnectselements', scope = schema_scope) + + :param isinterferedbyelements + :type isinterferedbyelements:SET(0,None,'ifcrelinterfereselements', scope = schema_scope) + + :param interfereselements + :type interfereselements:SET(0,None,'ifcrelinterfereselements', scope = schema_scope) + + :param hasprojections + :type hasprojections:SET(0,None,'ifcrelprojectselement', scope = schema_scope) + + :param referencedinstructures + :type referencedinstructures:SET(0,None,'ifcrelreferencedinspatialstructure', scope = schema_scope) + + :param hasopenings + :type hasopenings:SET(0,None,'ifcrelvoidselement', scope = schema_scope) + + :param isconnectionrealization + :type isconnectionrealization:SET(0,None,'ifcrelconnectswithrealizingelements', scope = schema_scope) + + :param providesboundaries + :type providesboundaries:SET(0,None,'ifcrelspaceboundary', scope = schema_scope) + + :param connectedfrom + :type connectedfrom:SET(0,None,'ifcrelconnectselements', scope = schema_scope) + + :param containedinstructure + :type containedinstructure:SET(0,1,'ifcrelcontainedinspatialstructure', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , tag, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.tag = tag + + @apply + def tag(): + def fget( self ): + return self._tag + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._tag = ifcidentifier(value) + else: + self._tag = value + else: + self._tag = value + return property(**locals()) + + @apply + def fillsvoids(): + def fget( self ): + return self._fillsvoids + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument fillsvoids is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def connectedto(): + def fget( self ): + return self._connectedto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isinterferedbyelements(): + def fget( self ): + return self._isinterferedbyelements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isinterferedbyelements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def interfereselements(): + def fget( self ): + return self._interfereselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument interfereselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasprojections(): + def fget( self ): + return self._hasprojections + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasprojections is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def referencedinstructures(): + def fget( self ): + return self._referencedinstructures + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referencedinstructures is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasopenings(): + def fget( self ): + return self._hasopenings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasopenings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isconnectionrealization(): + def fget( self ): + return self._isconnectionrealization + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isconnectionrealization is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def providesboundaries(): + def fget( self ): + return self._providesboundaries + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument providesboundaries is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def connectedfrom(): + def fget( self ): + return self._connectedfrom + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedfrom is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def containedinstructure(): + def fget( self ): + return self._containedinstructure + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containedinstructure is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcvirtualelement # +#################### +class ifcvirtualelement(ifcelement): + '''Entity ifcvirtualelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcpresentationitem # +#################### +class ifcpresentationitem(BaseEntityClass): + '''Entity ifcpresentationitem definition. + ''' + # This class does not define any attribute. + pass + +#################### + # ENTITY ifccurvestylefontpattern # +#################### +class ifccurvestylefontpattern(ifcpresentationitem): + '''Entity ifccurvestylefontpattern definition. + + :param visiblesegmentlength + :type visiblesegmentlength:ifclengthmeasure + + :param invisiblesegmentlength + :type invisiblesegmentlength:ifcpositivelengthmeasure + ''' + def __init__( self , visiblesegmentlength,invisiblesegmentlength, ): + ifcpresentationitem.__init__(self , ) + self.visiblesegmentlength = visiblesegmentlength + self.invisiblesegmentlength = invisiblesegmentlength + + @apply + def visiblesegmentlength(): + def fget( self ): + return self._visiblesegmentlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument visiblesegmentlength is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._visiblesegmentlength = ifclengthmeasure(value) + else: + self._visiblesegmentlength = value + return property(**locals()) + + @apply + def invisiblesegmentlength(): + def fget( self ): + return self._invisiblesegmentlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument invisiblesegmentlength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._invisiblesegmentlength = ifcpositivelengthmeasure(value) + else: + self._invisiblesegmentlength = value + return property(**locals()) + def visiblelengthgreaterequalzero(self): + eval_visiblelengthgreaterequalzero_wr = (self.visiblesegmentlength >= 0) + if not eval_visiblelengthgreaterequalzero_wr: + raise AssertionError('Rule visiblelengthgreaterequalzero violated') + else: + return eval_visiblelengthgreaterequalzero_wr + + +#################### + # ENTITY ifcrelconnectsstructuralactivity # +#################### +class ifcrelconnectsstructuralactivity(ifcrelconnects): + '''Entity ifcrelconnectsstructuralactivity definition. + + :param relatingelement + :type relatingelement:ifcstructuralactivityassignmentselect + + :param relatedstructuralactivity + :type relatedstructuralactivity:ifcstructuralactivity + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingelement,relatedstructuralactivity, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingelement = relatingelement + self.relatedstructuralactivity = relatedstructuralactivity + + @apply + def relatingelement(): + def fget( self ): + return self._relatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingelement is mantatory and can not be set to None') + if not check_type(value,ifcstructuralactivityassignmentselect): + self._relatingelement = ifcstructuralactivityassignmentselect(value) + else: + self._relatingelement = value + return property(**locals()) + + @apply + def relatedstructuralactivity(): + def fget( self ): + return self._relatedstructuralactivity + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedstructuralactivity is mantatory and can not be set to None') + if not check_type(value,ifcstructuralactivity): + self._relatedstructuralactivity = ifcstructuralactivity(value) + else: + self._relatedstructuralactivity = value + return property(**locals()) + +#################### + # ENTITY ifcdistributionelement # +#################### +class ifcdistributionelement(ifcelement): + '''Entity ifcdistributionelement definition. + + :param hasports + :type hasports:SET(0,None,'ifcrelconnectsporttoelement', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def hasports(): + def fget( self ): + return self._hasports + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasports is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcdistributionflowelement # +#################### +class ifcdistributionflowelement(ifcdistributionelement): + '''Entity ifcdistributionflowelement definition. + + :param hascontrolelements + :type hascontrolelements:SET(0,1,'ifcrelflowcontrolelements', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def hascontrolelements(): + def fget( self ): + return self._hascontrolelements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hascontrolelements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcflowterminal # +#################### +class ifcflowterminal(ifcdistributionflowelement): + '''Entity ifcflowterminal definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifclightfixture # +#################### +class ifclightfixture(ifcflowterminal): + '''Entity ifclightfixture definition. + + :param predefinedtype + :type predefinedtype:ifclightfixturetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclightfixturetypeenum): + self._predefinedtype = ifclightfixturetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifclightfixturetypeenum.self.userdefined)) or ((self.predefinedtype == ifclightfixturetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCLIGHTFIXTURETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcresourcelevelrelationship # +#################### +class ifcresourcelevelrelationship(BaseEntityClass): + '''Entity ifcresourcelevelrelationship definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + +#################### + # ENTITY ifcmaterialrelationship # +#################### +class ifcmaterialrelationship(ifcresourcelevelrelationship): + '''Entity ifcmaterialrelationship definition. + + :param relatingmaterial + :type relatingmaterial:ifcmaterial + + :param relatedmaterials + :type relatedmaterials:SET(1,None,'ifcmaterial', scope = schema_scope) + + :param expression + :type expression:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , relatingmaterial,relatedmaterials,expression, ): + ifcresourcelevelrelationship.__init__(self , inherited0__name , inherited1__description , ) + self.relatingmaterial = relatingmaterial + self.relatedmaterials = relatedmaterials + self.expression = expression + + @apply + def relatingmaterial(): + def fget( self ): + return self._relatingmaterial + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingmaterial is mantatory and can not be set to None') + if not check_type(value,ifcmaterial): + self._relatingmaterial = ifcmaterial(value) + else: + self._relatingmaterial = value + return property(**locals()) + + @apply + def relatedmaterials(): + def fget( self ): + return self._relatedmaterials + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedmaterials is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcmaterial', scope = schema_scope)): + self._relatedmaterials = SET(value) + else: + self._relatedmaterials = value + return property(**locals()) + + @apply + def expression(): + def fget( self ): + return self._expression + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._expression = ifclabel(value) + else: + self._expression = value + else: + self._expression = value + return property(**locals()) + +#################### + # ENTITY ifccontext # +#################### +class ifccontext(ifcobjectdefinition): + '''Entity ifccontext definition. + + :param objecttype + :type objecttype:ifclabel + + :param longname + :type longname:ifclabel + + :param phase + :type phase:ifclabel + + :param representationcontexts + :type representationcontexts:SET(1,None,'ifcrepresentationcontext', scope = schema_scope) + + :param unitsincontext + :type unitsincontext:ifcunitassignment + + :param isdefinedby + :type isdefinedby:SET(0,None,'ifcreldefinesbyproperties', scope = schema_scope) + + :param declares + :type declares:SET(0,None,'ifcreldeclares', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , objecttype,longname,phase,representationcontexts,unitsincontext, ): + ifcobjectdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.objecttype = objecttype + self.longname = longname + self.phase = phase + self.representationcontexts = representationcontexts + self.unitsincontext = unitsincontext + + @apply + def objecttype(): + def fget( self ): + return self._objecttype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._objecttype = ifclabel(value) + else: + self._objecttype = value + else: + self._objecttype = value + return property(**locals()) + + @apply + def longname(): + def fget( self ): + return self._longname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._longname = ifclabel(value) + else: + self._longname = value + else: + self._longname = value + return property(**locals()) + + @apply + def phase(): + def fget( self ): + return self._phase + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._phase = ifclabel(value) + else: + self._phase = value + else: + self._phase = value + return property(**locals()) + + @apply + def representationcontexts(): + def fget( self ): + return self._representationcontexts + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcrepresentationcontext', scope = schema_scope)): + self._representationcontexts = SET(value) + else: + self._representationcontexts = value + else: + self._representationcontexts = value + return property(**locals()) + + @apply + def unitsincontext(): + def fget( self ): + return self._unitsincontext + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunitassignment): + self._unitsincontext = ifcunitassignment(value) + else: + self._unitsincontext = value + else: + self._unitsincontext = value + return property(**locals()) + + @apply + def isdefinedby(): + def fget( self ): + return self._isdefinedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isdefinedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def declares(): + def fget( self ): + return self._declares + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument declares is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcpropertyabstraction # +#################### +class ifcpropertyabstraction(BaseEntityClass): + '''Entity ifcpropertyabstraction definition. + + :param hasexternalreferences + :type hasexternalreferences:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def hasexternalreferences(): + def fget( self ): + return self._hasexternalreferences + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreferences is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcpredefinedproperties # +#################### +class ifcpredefinedproperties(ifcpropertyabstraction): + '''Entity ifcpredefinedproperties definition. + ''' + def __init__( self , ): + ifcpropertyabstraction.__init__(self , ) + +#################### + # ENTITY ifcproperty # +#################### +class ifcproperty(ifcpropertyabstraction): + '''Entity ifcproperty definition. + + :param name + :type name:ifcidentifier + + :param description + :type description:ifctext + + :param partofpset + :type partofpset:SET(0,None,'ifcpropertyset', scope = schema_scope) + + :param propertyfordependance + :type propertyfordependance:SET(0,None,'ifcpropertydependencyrelationship', scope = schema_scope) + + :param propertydependson + :type propertydependson:SET(0,None,'ifcpropertydependencyrelationship', scope = schema_scope) + + :param partofcomplex + :type partofcomplex:SET(0,None,'ifccomplexproperty', scope = schema_scope) + ''' + def __init__( self , name,description, ): + ifcpropertyabstraction.__init__(self , ) + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._name = ifcidentifier(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def partofpset(): + def fget( self ): + return self._partofpset + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofpset is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def propertyfordependance(): + def fget( self ): + return self._propertyfordependance + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument propertyfordependance is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def propertydependson(): + def fget( self ): + return self._propertydependson + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument propertydependson is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def partofcomplex(): + def fget( self ): + return self._partofcomplex + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofcomplex is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsimpleproperty # +#################### +class ifcsimpleproperty(ifcproperty): + '''Entity ifcsimpleproperty definition. + ''' + def __init__( self , inherited0__name , inherited1__description , ): + ifcproperty.__init__(self , inherited0__name , inherited1__description , ) + +#################### + # ENTITY ifcpropertyenumeratedvalue # +#################### +class ifcpropertyenumeratedvalue(ifcsimpleproperty): + '''Entity ifcpropertyenumeratedvalue definition. + + :param enumerationvalues + :type enumerationvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param enumerationreference + :type enumerationreference:ifcpropertyenumeration + ''' + def __init__( self , inherited0__name , inherited1__description , enumerationvalues,enumerationreference, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.enumerationvalues = enumerationvalues + self.enumerationreference = enumerationreference + + @apply + def enumerationvalues(): + def fget( self ): + return self._enumerationvalues + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._enumerationvalues = LIST(value) + else: + self._enumerationvalues = value + else: + self._enumerationvalues = value + return property(**locals()) + + @apply + def enumerationreference(): + def fget( self ): + return self._enumerationreference + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpropertyenumeration): + self._enumerationreference = ifcpropertyenumeration(value) + else: + self._enumerationreference = value + else: + self._enumerationreference = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ((( not EXISTS(self.enumerationreference)) or ( not EXISTS(self.enumerationvalues))) or (SIZEOF(None) == SIZEOF(self.enumerationvalues))) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcreinforcementbarproperties # +#################### +class ifcreinforcementbarproperties(ifcpredefinedproperties): + '''Entity ifcreinforcementbarproperties definition. + + :param totalcrosssectionarea + :type totalcrosssectionarea:ifcareameasure + + :param steelgrade + :type steelgrade:ifclabel + + :param barsurface + :type barsurface:ifcreinforcingbarsurfaceenum + + :param effectivedepth + :type effectivedepth:ifclengthmeasure + + :param nominalbardiameter + :type nominalbardiameter:ifcpositivelengthmeasure + + :param barcount + :type barcount:ifccountmeasure + ''' + def __init__( self , totalcrosssectionarea,steelgrade,barsurface,effectivedepth,nominalbardiameter,barcount, ): + ifcpredefinedproperties.__init__(self , ) + self.totalcrosssectionarea = totalcrosssectionarea + self.steelgrade = steelgrade + self.barsurface = barsurface + self.effectivedepth = effectivedepth + self.nominalbardiameter = nominalbardiameter + self.barcount = barcount + + @apply + def totalcrosssectionarea(): + def fget( self ): + return self._totalcrosssectionarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument totalcrosssectionarea is mantatory and can not be set to None') + if not check_type(value,ifcareameasure): + self._totalcrosssectionarea = ifcareameasure(value) + else: + self._totalcrosssectionarea = value + return property(**locals()) + + @apply + def steelgrade(): + def fget( self ): + return self._steelgrade + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument steelgrade is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._steelgrade = ifclabel(value) + else: + self._steelgrade = value + return property(**locals()) + + @apply + def barsurface(): + def fget( self ): + return self._barsurface + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreinforcingbarsurfaceenum): + self._barsurface = ifcreinforcingbarsurfaceenum(value) + else: + self._barsurface = value + else: + self._barsurface = value + return property(**locals()) + + @apply + def effectivedepth(): + def fget( self ): + return self._effectivedepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._effectivedepth = ifclengthmeasure(value) + else: + self._effectivedepth = value + else: + self._effectivedepth = value + return property(**locals()) + + @apply + def nominalbardiameter(): + def fget( self ): + return self._nominalbardiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominalbardiameter = ifcpositivelengthmeasure(value) + else: + self._nominalbardiameter = value + else: + self._nominalbardiameter = value + return property(**locals()) + + @apply + def barcount(): + def fget( self ): + return self._barcount + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccountmeasure): + self._barcount = ifccountmeasure(value) + else: + self._barcount = value + else: + self._barcount = value + return property(**locals()) + +#################### + # ENTITY ifcrepresentationitem # +#################### +class ifcrepresentationitem(BaseEntityClass): + '''Entity ifcrepresentationitem definition. + + :param layerassignment + :type layerassignment:SET(0,1,'ifcpresentationlayerassignment', scope = schema_scope) + + :param styledbyitem + :type styledbyitem:SET(0,1,'ifcstyleditem', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def layerassignment(): + def fget( self ): + return self._layerassignment + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument layerassignment is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def styledbyitem(): + def fget( self ): + return self._styledbyitem + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument styledbyitem is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcgeometricrepresentationitem # +#################### +class ifcgeometricrepresentationitem(ifcrepresentationitem): + '''Entity ifcgeometricrepresentationitem definition. + ''' + def __init__( self , ): + ifcrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifcsurface # +#################### +class ifcsurface(ifcgeometricrepresentationitem): + '''Entity ifcsurface definition. + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsweptsurface # +#################### +class ifcsweptsurface(ifcsurface): + '''Entity ifcsweptsurface definition. + + :param sweptcurve + :type sweptcurve:ifcprofiledef + + :param position + :type position:ifcaxis2placement3d + ''' + def __init__( self , sweptcurve,position, ): + ifcsurface.__init__(self , ) + self.sweptcurve = sweptcurve + self.position = position + + @apply + def sweptcurve(): + def fget( self ): + return self._sweptcurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sweptcurve is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._sweptcurve = ifcprofiledef(value) + else: + self._sweptcurve = value + return property(**locals()) + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + else: + self._position = value + return property(**locals()) + def sweptcurvetype(self): + eval_sweptcurvetype_wr = (self.sweptcurve.self.profiletype == ifcprofiletypeenum.self.curve) + if not eval_sweptcurvetype_wr: + raise AssertionError('Rule sweptcurvetype violated') + else: + return eval_sweptcurvetype_wr + + +#################### + # ENTITY ifcsurfaceofrevolution # +#################### +class ifcsurfaceofrevolution(ifcsweptsurface): + '''Entity ifcsurfaceofrevolution definition. + + :param axisposition + :type axisposition:ifcaxis1placement + + :param axisline + :type axisline:ifcline + ''' + def __init__( self , inherited0__sweptcurve , inherited1__position , axisposition, ): + ifcsweptsurface.__init__(self , inherited0__sweptcurve , inherited1__position , ) + self.axisposition = axisposition + + @apply + def axisposition(): + def fget( self ): + return self._axisposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axisposition is mantatory and can not be set to None') + if not check_type(value,ifcaxis1placement): + self._axisposition = ifcaxis1placement(value) + else: + self._axisposition = value + return property(**locals()) + + @apply + def axisline(): + def fget( self ): + attribute_eval = (((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifccurve()) == ifcline(self.axisposition.self.location,(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(self.axisposition.self.z,1))) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument axisline is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcflowtreatmentdevice # +#################### +class ifcflowtreatmentdevice(ifcdistributionflowelement): + '''Entity ifcflowtreatmentdevice definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcinterceptor # +#################### +class ifcinterceptor(ifcflowtreatmentdevice): + '''Entity ifcinterceptor definition. + + :param predefinedtype + :type predefinedtype:ifcinterceptortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowtreatmentdevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcinterceptortypeenum): + self._predefinedtype = ifcinterceptortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcinterceptortypeenum.self.userdefined)) or ((self.predefinedtype == ifcinterceptortypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCINTERCEPTORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifctypeobject # +#################### +class ifctypeobject(ifcobjectdefinition): + '''Entity ifctypeobject definition. + + :param applicableoccurrence + :type applicableoccurrence:ifcidentifier + + :param haspropertysets + :type haspropertysets:SET(1,None,'ifcpropertysetdefinition', scope = schema_scope) + + :param types + :type types:SET(0,1,'ifcreldefinesbytype', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , applicableoccurrence,haspropertysets, ): + ifcobjectdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.applicableoccurrence = applicableoccurrence + self.haspropertysets = haspropertysets + + @apply + def applicableoccurrence(): + def fget( self ): + return self._applicableoccurrence + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._applicableoccurrence = ifcidentifier(value) + else: + self._applicableoccurrence = value + else: + self._applicableoccurrence = value + return property(**locals()) + + @apply + def haspropertysets(): + def fget( self ): + return self._haspropertysets + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcpropertysetdefinition', scope = schema_scope)): + self._haspropertysets = SET(value) + else: + self._haspropertysets = value + else: + self._haspropertysets = value + return property(**locals()) + + @apply + def types(): + def fget( self ): + return self._types + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument types is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifctypeproduct # +#################### +class ifctypeproduct(ifctypeobject): + '''Entity ifctypeproduct definition. + + :param representationmaps + :type representationmaps:LIST(1,None,'ifcrepresentationmap', scope = schema_scope) + + :param tag + :type tag:ifclabel + + :param referencedby + :type referencedby:SET(0,None,'ifcrelassignstoproduct', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , representationmaps,tag, ): + ifctypeobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , ) + self.representationmaps = representationmaps + self.tag = tag + + @apply + def representationmaps(): + def fget( self ): + return self._representationmaps + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcrepresentationmap', scope = schema_scope)): + self._representationmaps = LIST(value) + else: + self._representationmaps = value + else: + self._representationmaps = value + return property(**locals()) + + @apply + def tag(): + def fget( self ): + return self._tag + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._tag = ifclabel(value) + else: + self._tag = value + else: + self._tag = value + return property(**locals()) + + @apply + def referencedby(): + def fget( self ): + return self._referencedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referencedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def applicableoccurrence(self): + eval_applicableoccurrence_wr = (( not EXISTS(self.self.ifctypeobject.self.types[1])) or (SIZEOF(None) == 0)) + if not eval_applicableoccurrence_wr: + raise AssertionError('Rule applicableoccurrence violated') + else: + return eval_applicableoccurrence_wr + + +#################### + # ENTITY ifcelementtype # +#################### +class ifcelementtype(ifctypeproduct): + '''Entity ifcelementtype definition. + + :param elementtype + :type elementtype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , elementtype, ): + ifctypeproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , ) + self.elementtype = elementtype + + @apply + def elementtype(): + def fget( self ): + return self._elementtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._elementtype = ifclabel(value) + else: + self._elementtype = value + else: + self._elementtype = value + return property(**locals()) + +#################### + # ENTITY ifcdistributionelementtype # +#################### +class ifcdistributionelementtype(ifcelementtype): + '''Entity ifcdistributionelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcdistributionflowelementtype # +#################### +class ifcdistributionflowelementtype(ifcdistributionelementtype): + '''Entity ifcdistributionflowelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcflowsegmenttype # +#################### +class ifcflowsegmenttype(ifcdistributionflowelementtype): + '''Entity ifcflowsegmenttype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifccablesegmenttype # +#################### +class ifccablesegmenttype(ifcflowsegmenttype): + '''Entity ifccablesegmenttype definition. + + :param predefinedtype + :type predefinedtype:ifccablesegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowsegmenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccablesegmenttypeenum): + self._predefinedtype = ifccablesegmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccablesegmenttypeenum.self.userdefined) or ((self.predefinedtype == ifccablesegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifctyperesource # +#################### +class ifctyperesource(ifctypeobject): + '''Entity ifctyperesource definition. + + :param identification + :type identification:ifcidentifier + + :param longdescription + :type longdescription:ifctext + + :param resourcetype + :type resourcetype:ifclabel + + :param resourceof + :type resourceof:SET(0,None,'ifcrelassignstoresource', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , identification,longdescription,resourcetype, ): + ifctypeobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , ) + self.identification = identification + self.longdescription = longdescription + self.resourcetype = resourcetype + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + else: + self._identification = value + return property(**locals()) + + @apply + def longdescription(): + def fget( self ): + return self._longdescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._longdescription = ifctext(value) + else: + self._longdescription = value + else: + self._longdescription = value + return property(**locals()) + + @apply + def resourcetype(): + def fget( self ): + return self._resourcetype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._resourcetype = ifclabel(value) + else: + self._resourcetype = value + else: + self._resourcetype = value + return property(**locals()) + + @apply + def resourceof(): + def fget( self ): + return self._resourceof + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument resourceof is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcconstructionresourcetype # +#################### +class ifcconstructionresourcetype(ifctyperesource): + '''Entity ifcconstructionresourcetype definition. + + :param basecosts + :type basecosts:LIST(1,None,'ifcappliedvalue', scope = schema_scope) + + :param basequantity + :type basequantity:ifcphysicalquantity + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , basecosts,basequantity, ): + ifctyperesource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , ) + self.basecosts = basecosts + self.basequantity = basequantity + + @apply + def basecosts(): + def fget( self ): + return self._basecosts + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcappliedvalue', scope = schema_scope)): + self._basecosts = LIST(value) + else: + self._basecosts = value + else: + self._basecosts = value + return property(**locals()) + + @apply + def basequantity(): + def fget( self ): + return self._basequantity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcphysicalquantity): + self._basequantity = ifcphysicalquantity(value) + else: + self._basequantity = value + else: + self._basequantity = value + return property(**locals()) + +#################### + # ENTITY ifcconstructionproductresourcetype # +#################### +class ifcconstructionproductresourcetype(ifcconstructionresourcetype): + '''Entity ifcconstructionproductresourcetype definition. + + :param predefinedtype + :type predefinedtype:ifcconstructionproductresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , predefinedtype, ): + ifcconstructionresourcetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcconstructionproductresourcetypeenum): + self._predefinedtype = ifcconstructionproductresourcetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcconstructionproductresourcetypeenum.self.userdefined) or ((self.predefinedtype == ifcconstructionproductresourcetypeenum.self.userdefined) and EXISTS(self.self.ifctyperesource.self.resourcetype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpropertydefinition # +#################### +class ifcpropertydefinition(ifcroot): + '''Entity ifcpropertydefinition definition. + + :param hascontext + :type hascontext:SET(0,1,'ifcreldeclares', scope = schema_scope) + + :param hasassociations + :type hasassociations:SET(0,None,'ifcrelassociates', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcroot.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + + @apply + def hascontext(): + def fget( self ): + return self._hascontext + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hascontext is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasassociations(): + def fget( self ): + return self._hasassociations + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasassociations is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcpropertysetdefinition # +#################### +class ifcpropertysetdefinition(ifcpropertydefinition): + '''Entity ifcpropertysetdefinition definition. + + :param definestype + :type definestype:SET(0,None,'ifctypeobject', scope = schema_scope) + + :param isdefinedby + :type isdefinedby:SET(0,None,'ifcreldefinesbytemplate', scope = schema_scope) + + :param definesoccurrence + :type definesoccurrence:SET(0,1,'ifcreldefinesbyproperties', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcpropertydefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + + @apply + def definestype(): + def fget( self ): + return self._definestype + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument definestype is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isdefinedby(): + def fget( self ): + return self._isdefinedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isdefinedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def definesoccurrence(): + def fget( self ): + return self._definesoccurrence + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument definesoccurrence is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcquantityset # +#################### +class ifcquantityset(ifcpropertysetdefinition): + '''Entity ifcquantityset definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + +#################### + # ENTITY ifcelementquantity # +#################### +class ifcelementquantity(ifcquantityset): + '''Entity ifcelementquantity definition. + + :param methodofmeasurement + :type methodofmeasurement:ifclabel + + :param quantities + :type quantities:SET(1,None,'ifcphysicalquantity', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , methodofmeasurement,quantities, ): + ifcquantityset.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.methodofmeasurement = methodofmeasurement + self.quantities = quantities + + @apply + def methodofmeasurement(): + def fget( self ): + return self._methodofmeasurement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._methodofmeasurement = ifclabel(value) + else: + self._methodofmeasurement = value + else: + self._methodofmeasurement = value + return property(**locals()) + + @apply + def quantities(): + def fget( self ): + return self._quantities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument quantities is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcphysicalquantity', scope = schema_scope)): + self._quantities = SET(value) + else: + self._quantities = value + return property(**locals()) + def uniquequantitynames(self): + eval_uniquequantitynames_wr = ifcuniquequantitynames(self.quantities) + if not eval_uniquequantitynames_wr: + raise AssertionError('Rule uniquequantitynames violated') + else: + return eval_uniquequantitynames_wr + + +#################### + # ENTITY ifcenergyconversiondevicetype # +#################### +class ifcenergyconversiondevicetype(ifcdistributionflowelementtype): + '''Entity ifcenergyconversiondevicetype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifchumidifiertype # +#################### +class ifchumidifiertype(ifcenergyconversiondevicetype): + '''Entity ifchumidifiertype definition. + + :param predefinedtype + :type predefinedtype:ifchumidifiertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifchumidifiertypeenum): + self._predefinedtype = ifchumidifiertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifchumidifiertypeenum.self.userdefined) or ((self.predefinedtype == ifchumidifiertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcstructuralitem # +#################### +class ifcstructuralitem(ifcproduct): + '''Entity ifcstructuralitem definition. + + :param assignedstructuralactivity + :type assignedstructuralactivity:SET(0,None,'ifcrelconnectsstructuralactivity', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + + @apply + def assignedstructuralactivity(): + def fget( self ): + return self._assignedstructuralactivity + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument assignedstructuralactivity is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructuralload # +#################### +class ifcstructuralload(BaseEntityClass): + '''Entity ifcstructuralload definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralloadorresult # +#################### +class ifcstructuralloadorresult(ifcstructuralload): + '''Entity ifcstructuralloadorresult definition. + ''' + def __init__( self , inherited0__name , ): + ifcstructuralload.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcstructuralloadstatic # +#################### +class ifcstructuralloadstatic(ifcstructuralloadorresult): + '''Entity ifcstructuralloadstatic definition. + ''' + def __init__( self , inherited0__name , ): + ifcstructuralloadorresult.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcstructuralloadsingledisplacement # +#################### +class ifcstructuralloadsingledisplacement(ifcstructuralloadstatic): + '''Entity ifcstructuralloadsingledisplacement definition. + + :param displacementx + :type displacementx:ifclengthmeasure + + :param displacementy + :type displacementy:ifclengthmeasure + + :param displacementz + :type displacementz:ifclengthmeasure + + :param rotationaldisplacementrx + :type rotationaldisplacementrx:ifcplaneanglemeasure + + :param rotationaldisplacementry + :type rotationaldisplacementry:ifcplaneanglemeasure + + :param rotationaldisplacementrz + :type rotationaldisplacementrz:ifcplaneanglemeasure + ''' + def __init__( self , inherited0__name , displacementx,displacementy,displacementz,rotationaldisplacementrx,rotationaldisplacementry,rotationaldisplacementrz, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.displacementx = displacementx + self.displacementy = displacementy + self.displacementz = displacementz + self.rotationaldisplacementrx = rotationaldisplacementrx + self.rotationaldisplacementry = rotationaldisplacementry + self.rotationaldisplacementrz = rotationaldisplacementrz + + @apply + def displacementx(): + def fget( self ): + return self._displacementx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._displacementx = ifclengthmeasure(value) + else: + self._displacementx = value + else: + self._displacementx = value + return property(**locals()) + + @apply + def displacementy(): + def fget( self ): + return self._displacementy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._displacementy = ifclengthmeasure(value) + else: + self._displacementy = value + else: + self._displacementy = value + return property(**locals()) + + @apply + def displacementz(): + def fget( self ): + return self._displacementz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._displacementz = ifclengthmeasure(value) + else: + self._displacementz = value + else: + self._displacementz = value + return property(**locals()) + + @apply + def rotationaldisplacementrx(): + def fget( self ): + return self._rotationaldisplacementrx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._rotationaldisplacementrx = ifcplaneanglemeasure(value) + else: + self._rotationaldisplacementrx = value + else: + self._rotationaldisplacementrx = value + return property(**locals()) + + @apply + def rotationaldisplacementry(): + def fget( self ): + return self._rotationaldisplacementry + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._rotationaldisplacementry = ifcplaneanglemeasure(value) + else: + self._rotationaldisplacementry = value + else: + self._rotationaldisplacementry = value + return property(**locals()) + + @apply + def rotationaldisplacementrz(): + def fget( self ): + return self._rotationaldisplacementrz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._rotationaldisplacementrz = ifcplaneanglemeasure(value) + else: + self._rotationaldisplacementrz = value + else: + self._rotationaldisplacementrz = value + return property(**locals()) + +#################### + # ENTITY ifctransportelementtype # +#################### +class ifctransportelementtype(ifcelementtype): + '''Entity ifctransportelementtype definition. + + :param predefinedtype + :type predefinedtype:ifctransportelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctransportelementtypeenum): + self._predefinedtype = ifctransportelementtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifctransportelementtypeenum.self.userdefined) or ((self.predefinedtype == ifctransportelementtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcprofiledef # +#################### +class ifcprofiledef(BaseEntityClass): + '''Entity ifcprofiledef definition. + + :param profiletype + :type profiletype:ifcprofiletypeenum + + :param profilename + :type profilename:ifclabel + + :param hasexternalreference + :type hasexternalreference:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + + :param hasproperties + :type hasproperties:SET(0,None,'ifcprofileproperties', scope = schema_scope) + ''' + def __init__( self , profiletype,profilename, ): + self.profiletype = profiletype + self.profilename = profilename + + @apply + def profiletype(): + def fget( self ): + return self._profiletype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument profiletype is mantatory and can not be set to None') + if not check_type(value,ifcprofiletypeenum): + self._profiletype = ifcprofiletypeenum(value) + else: + self._profiletype = value + return property(**locals()) + + @apply + def profilename(): + def fget( self ): + return self._profilename + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._profilename = ifclabel(value) + else: + self._profilename = value + else: + self._profilename = value + return property(**locals()) + + @apply + def hasexternalreference(): + def fget( self ): + return self._hasexternalreference + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreference is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasproperties(): + def fget( self ): + return self._hasproperties + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasproperties is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcparameterizedprofiledef # +#################### +class ifcparameterizedprofiledef(ifcprofiledef): + '''Entity ifcparameterizedprofiledef definition. + + :param position + :type position:ifcaxis2placement2d + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , position, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaxis2placement2d): + self._position = ifcaxis2placement2d(value) + else: + self._position = value + else: + self._position = value + return property(**locals()) + +#################### + # ENTITY ifctrapeziumprofiledef # +#################### +class ifctrapeziumprofiledef(ifcparameterizedprofiledef): + '''Entity ifctrapeziumprofiledef definition. + + :param bottomxdim + :type bottomxdim:ifcpositivelengthmeasure + + :param topxdim + :type topxdim:ifcpositivelengthmeasure + + :param ydim + :type ydim:ifcpositivelengthmeasure + + :param topxoffset + :type topxoffset:ifclengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , bottomxdim,topxdim,ydim,topxoffset, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.bottomxdim = bottomxdim + self.topxdim = topxdim + self.ydim = ydim + self.topxoffset = topxoffset + + @apply + def bottomxdim(): + def fget( self ): + return self._bottomxdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bottomxdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._bottomxdim = ifcpositivelengthmeasure(value) + else: + self._bottomxdim = value + return property(**locals()) + + @apply + def topxdim(): + def fget( self ): + return self._topxdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument topxdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._topxdim = ifcpositivelengthmeasure(value) + else: + self._topxdim = value + return property(**locals()) + + @apply + def ydim(): + def fget( self ): + return self._ydim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ydim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ydim = ifcpositivelengthmeasure(value) + else: + self._ydim = value + return property(**locals()) + + @apply + def topxoffset(): + def fget( self ): + return self._topxoffset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument topxoffset is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._topxoffset = ifclengthmeasure(value) + else: + self._topxoffset = value + return property(**locals()) + +#################### + # ENTITY ifczshapeprofiledef # +#################### +class ifczshapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifczshapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param flangewidth + :type flangewidth:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param flangethickness + :type flangethickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcnonnegativelengthmeasure + + :param edgeradius + :type edgeradius:ifcnonnegativelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,flangewidth,webthickness,flangethickness,filletradius,edgeradius, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.flangewidth = flangewidth + self.webthickness = webthickness + self.flangethickness = flangethickness + self.filletradius = filletradius + self.edgeradius = edgeradius + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def flangewidth(): + def fget( self ): + return self._flangewidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangewidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangewidth = ifcpositivelengthmeasure(value) + else: + self._flangewidth = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def flangethickness(): + def fget( self ): + return self._flangethickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangethickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangethickness = ifcpositivelengthmeasure(value) + else: + self._flangethickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._filletradius = ifcnonnegativelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + + @apply + def edgeradius(): + def fget( self ): + return self._edgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._edgeradius = ifcnonnegativelengthmeasure(value) + else: + self._edgeradius = value + else: + self._edgeradius = value + return property(**locals()) + def validflangethickness(self): + eval_validflangethickness_wr = (self.flangethickness < (self.depth / 2)) + if not eval_validflangethickness_wr: + raise AssertionError('Rule validflangethickness violated') + else: + return eval_validflangethickness_wr + + +#################### + # ENTITY ifccontrol # +#################### +class ifccontrol(ifcobject): + '''Entity ifccontrol definition. + + :param identification + :type identification:ifcidentifier + + :param controls + :type controls:SET(0,None,'ifcrelassignstocontrol', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , identification, ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.identification = identification + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + else: + self._identification = value + return property(**locals()) + + @apply + def controls(): + def fget( self ): + return self._controls + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument controls is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifccostitem # +#################### +class ifccostitem(ifccontrol): + '''Entity ifccostitem definition. + + :param predefinedtype + :type predefinedtype:ifccostitemtypeenum + + :param costvalues + :type costvalues:LIST(1,None,'ifccostvalue', scope = schema_scope) + + :param costquantities + :type costquantities:LIST(1,None,'ifcphysicalquantity', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , predefinedtype,costvalues,costquantities, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , ) + self.predefinedtype = predefinedtype + self.costvalues = costvalues + self.costquantities = costquantities + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostitemtypeenum): + self._predefinedtype = ifccostitemtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def costvalues(): + def fget( self ): + return self._costvalues + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifccostvalue', scope = schema_scope)): + self._costvalues = LIST(value) + else: + self._costvalues = value + else: + self._costvalues = value + return property(**locals()) + + @apply + def costquantities(): + def fget( self ): + return self._costquantities + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcphysicalquantity', scope = schema_scope)): + self._costquantities = LIST(value) + else: + self._costquantities = value + else: + self._costquantities = value + return property(**locals()) + +#################### + # ENTITY ifclightsource # +#################### +class ifclightsource(ifcgeometricrepresentationitem): + '''Entity ifclightsource definition. + + :param name + :type name:ifclabel + + :param lightcolour + :type lightcolour:ifccolourrgb + + :param ambientintensity + :type ambientintensity:ifcnormalisedratiomeasure + + :param intensity + :type intensity:ifcnormalisedratiomeasure + ''' + def __init__( self , name,lightcolour,ambientintensity,intensity, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.name = name + self.lightcolour = lightcolour + self.ambientintensity = ambientintensity + self.intensity = intensity + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def lightcolour(): + def fget( self ): + return self._lightcolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lightcolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._lightcolour = ifccolourrgb(value) + else: + self._lightcolour = value + return property(**locals()) + + @apply + def ambientintensity(): + def fget( self ): + return self._ambientintensity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._ambientintensity = ifcnormalisedratiomeasure(value) + else: + self._ambientintensity = value + else: + self._ambientintensity = value + return property(**locals()) + + @apply + def intensity(): + def fget( self ): + return self._intensity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._intensity = ifcnormalisedratiomeasure(value) + else: + self._intensity = value + else: + self._intensity = value + return property(**locals()) + +#################### + # ENTITY ifcsolidmodel # +#################### +class ifcsolidmodel(ifcgeometricrepresentationitem): + '''Entity ifcsolidmodel definition. + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcmanifoldsolidbrep # +#################### +class ifcmanifoldsolidbrep(ifcsolidmodel): + '''Entity ifcmanifoldsolidbrep definition. + + :param outer + :type outer:ifcclosedshell + ''' + def __init__( self , outer, ): + ifcsolidmodel.__init__(self , ) + self.outer = outer + + @apply + def outer(): + def fget( self ): + return self._outer + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument outer is mantatory and can not be set to None') + if not check_type(value,ifcclosedshell): + self._outer = ifcclosedshell(value) + else: + self._outer = value + return property(**locals()) + +#################### + # ENTITY ifcadvancedbrep # +#################### +class ifcadvancedbrep(ifcmanifoldsolidbrep): + '''Entity ifcadvancedbrep definition. + ''' + def __init__( self , inherited0__outer , ): + ifcmanifoldsolidbrep.__init__(self , inherited0__outer , ) + def hasadvancedfaces(self): + eval_hasadvancedfaces_wr = (SIZEOF(None) == 0) + if not eval_hasadvancedfaces_wr: + raise AssertionError('Rule hasadvancedfaces violated') + else: + return eval_hasadvancedfaces_wr + + +#################### + # ENTITY ifcadvancedbrepwithvoids # +#################### +class ifcadvancedbrepwithvoids(ifcadvancedbrep): + '''Entity ifcadvancedbrepwithvoids definition. + + :param voids + :type voids:SET(1,None,'ifcclosedshell', scope = schema_scope) + ''' + def __init__( self , inherited0__outer , voids, ): + ifcadvancedbrep.__init__(self , inherited0__outer , ) + self.voids = voids + + @apply + def voids(): + def fget( self ): + return self._voids + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument voids is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcclosedshell', scope = schema_scope)): + self._voids = SET(value) + else: + self._voids = value + return property(**locals()) + def voidshaveadvancedfaces(self): + eval_voidshaveadvancedfaces_wr = (SIZEOF(None) == 0) + if not eval_voidshaveadvancedfaces_wr: + raise AssertionError('Rule voidshaveadvancedfaces violated') + else: + return eval_voidshaveadvancedfaces_wr + + +#################### + # ENTITY ifcfeatureelement # +#################### +class ifcfeatureelement(ifcelement): + '''Entity ifcfeatureelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcfeatureelementaddition # +#################### +class ifcfeatureelementaddition(ifcfeatureelement): + '''Entity ifcfeatureelementaddition definition. + + :param projectselements + :type projectselements:ifcrelprojectselement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcfeatureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def projectselements(): + def fget( self ): + return self._projectselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument projectselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructuralconnectioncondition # +#################### +class ifcstructuralconnectioncondition(BaseEntityClass): + '''Entity ifcstructuralconnectioncondition definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcpoint # +#################### +class ifcpoint(ifcgeometricrepresentationitem): + '''Entity ifcpoint definition. + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifccartesianpoint # +#################### +class ifccartesianpoint(ifcpoint): + '''Entity ifccartesianpoint definition. + + :param coordinates + :type coordinates:LIST(1,3,'REAL', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , coordinates, ): + ifcpoint.__init__(self , ) + self.coordinates = coordinates + + @apply + def coordinates(): + def fget( self ): + return self._coordinates + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordinates is mantatory and can not be set to None') + if not check_type(value,LIST(1,3,'REAL', scope = schema_scope)): + self._coordinates = LIST(value) + else: + self._coordinates = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = HIINDEX(self.coordinates) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def cp2dor3d(self): + eval_cp2dor3d_wr = (HIINDEX(self.coordinates) >= 2) + if not eval_cp2dor3d_wr: + raise AssertionError('Rule cp2dor3d violated') + else: + return eval_cp2dor3d_wr + + +#################### + # ENTITY ifcexternalreference # +#################### +class ifcexternalreference(BaseEntityClass): + '''Entity ifcexternalreference definition. + + :param location + :type location:ifcurireference + + :param identification + :type identification:ifcidentifier + + :param name + :type name:ifclabel + + :param externalreferenceforresources + :type externalreferenceforresources:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + ''' + def __init__( self , location,identification,name, ): + self.location = location + self.identification = identification + self.name = name + + @apply + def location(): + def fget( self ): + return self._location + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcurireference): + self._location = ifcurireference(value) + else: + self._location = value + else: + self._location = value + return property(**locals()) + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + else: + self._identification = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def externalreferenceforresources(): + def fget( self ): + return self._externalreferenceforresources + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument externalreferenceforresources is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((EXISTS(self.identification) or EXISTS(self.location)) or EXISTS(self.name)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcclassificationreference # +#################### +class ifcclassificationreference(ifcexternalreference): + '''Entity ifcclassificationreference definition. + + :param referencedsource + :type referencedsource:ifcclassificationreferenceselect + + :param description + :type description:ifctext + + :param sort + :type sort:ifcidentifier + + :param classificationrefforobjects + :type classificationrefforobjects:SET(0,None,'ifcrelassociatesclassification', scope = schema_scope) + + :param hasreferences + :type hasreferences:SET(0,None,'ifcclassificationreference', scope = schema_scope) + ''' + def __init__( self , inherited0__location , inherited1__identification , inherited2__name , referencedsource,description,sort, ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__identification , inherited2__name , ) + self.referencedsource = referencedsource + self.description = description + self.sort = sort + + @apply + def referencedsource(): + def fget( self ): + return self._referencedsource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcclassificationreferenceselect): + self._referencedsource = ifcclassificationreferenceselect(value) + else: + self._referencedsource = value + else: + self._referencedsource = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def sort(): + def fget( self ): + return self._sort + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._sort = ifcidentifier(value) + else: + self._sort = value + else: + self._sort = value + return property(**locals()) + + @apply + def classificationrefforobjects(): + def fget( self ): + return self._classificationrefforobjects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument classificationrefforobjects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasreferences(): + def fget( self ): + return self._hasreferences + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasreferences is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcderivedunitelement # +#################### +class ifcderivedunitelement(BaseEntityClass): + '''Entity ifcderivedunitelement definition. + + :param unit + :type unit:ifcnamedunit + + :param exponent + :type exponent:INTEGER + ''' + def __init__( self , unit,exponent, ): + self.unit = unit + self.exponent = exponent + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unit is mantatory and can not be set to None') + if not check_type(value,ifcnamedunit): + self._unit = ifcnamedunit(value) + else: + self._unit = value + return property(**locals()) + + @apply + def exponent(): + def fget( self ): + return self._exponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument exponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._exponent = INTEGER(value) + else: + self._exponent = value + return property(**locals()) + +#################### + # ENTITY ifcbuildingelement # +#################### +class ifcbuildingelement(ifcelement): + '''Entity ifcbuildingelement definition. + + :param hascoverings + :type hascoverings:SET(0,None,'ifcrelcoversbldgelements', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def hascoverings(): + def fget( self ): + return self._hascoverings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hascoverings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def maxonematerialassociation(self): + eval_maxonematerialassociation_wr = (SIZEOF(None) <= 1) + if not eval_maxonematerialassociation_wr: + raise AssertionError('Rule maxonematerialassociation violated') + else: + return eval_maxonematerialassociation_wr + + +#################### + # ENTITY ifcrailing # +#################### +class ifcrailing(ifcbuildingelement): + '''Entity ifcrailing definition. + + :param predefinedtype + :type predefinedtype:ifcrailingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrailingtypeenum): + self._predefinedtype = ifcrailingtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcrailingtypeenum.self.userdefined)) or ((self.predefinedtype == ifcrailingtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCRAILINGTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcshadingdevice # +#################### +class ifcshadingdevice(ifcbuildingelement): + '''Entity ifcshadingdevice definition. + + :param predefinedtype + :type predefinedtype:ifcshadingdevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshadingdevicetypeenum): + self._predefinedtype = ifcshadingdevicetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcshadingdevicetypeenum.self.userdefined)) or ((self.predefinedtype == ifcshadingdevicetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSHADINGDEVICETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifccurrencyrelationship # +#################### +class ifccurrencyrelationship(ifcresourcelevelrelationship): + '''Entity ifccurrencyrelationship definition. + + :param relatingmonetaryunit + :type relatingmonetaryunit:ifcmonetaryunit + + :param relatedmonetaryunit + :type relatedmonetaryunit:ifcmonetaryunit + + :param exchangerate + :type exchangerate:ifcpositiveratiomeasure + + :param ratedatetime + :type ratedatetime:ifcdatetime + + :param ratesource + :type ratesource:ifclibraryinformation + ''' + def __init__( self , inherited0__name , inherited1__description , relatingmonetaryunit,relatedmonetaryunit,exchangerate,ratedatetime,ratesource, ): + ifcresourcelevelrelationship.__init__(self , inherited0__name , inherited1__description , ) + self.relatingmonetaryunit = relatingmonetaryunit + self.relatedmonetaryunit = relatedmonetaryunit + self.exchangerate = exchangerate + self.ratedatetime = ratedatetime + self.ratesource = ratesource + + @apply + def relatingmonetaryunit(): + def fget( self ): + return self._relatingmonetaryunit + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingmonetaryunit is mantatory and can not be set to None') + if not check_type(value,ifcmonetaryunit): + self._relatingmonetaryunit = ifcmonetaryunit(value) + else: + self._relatingmonetaryunit = value + return property(**locals()) + + @apply + def relatedmonetaryunit(): + def fget( self ): + return self._relatedmonetaryunit + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedmonetaryunit is mantatory and can not be set to None') + if not check_type(value,ifcmonetaryunit): + self._relatedmonetaryunit = ifcmonetaryunit(value) + else: + self._relatedmonetaryunit = value + return property(**locals()) + + @apply + def exchangerate(): + def fget( self ): + return self._exchangerate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument exchangerate is mantatory and can not be set to None') + if not check_type(value,ifcpositiveratiomeasure): + self._exchangerate = ifcpositiveratiomeasure(value) + else: + self._exchangerate = value + return property(**locals()) + + @apply + def ratedatetime(): + def fget( self ): + return self._ratedatetime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._ratedatetime = ifcdatetime(value) + else: + self._ratedatetime = value + else: + self._ratedatetime = value + return property(**locals()) + + @apply + def ratesource(): + def fget( self ): + return self._ratesource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclibraryinformation): + self._ratesource = ifclibraryinformation(value) + else: + self._ratesource = value + else: + self._ratesource = value + return property(**locals()) + +#################### + # ENTITY ifcmaterialdefinition # +#################### +class ifcmaterialdefinition(BaseEntityClass): + '''Entity ifcmaterialdefinition definition. + + :param associatedto + :type associatedto:SET(0,None,'ifcrelassociatesmaterial', scope = schema_scope) + + :param hasexternalreferences + :type hasexternalreferences:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + + :param hasproperties + :type hasproperties:SET(0,None,'ifcmaterialproperties', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def associatedto(): + def fget( self ): + return self._associatedto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument associatedto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasexternalreferences(): + def fget( self ): + return self._hasexternalreferences + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreferences is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasproperties(): + def fget( self ): + return self._hasproperties + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasproperties is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcmaterial # +#################### +class ifcmaterial(ifcmaterialdefinition): + '''Entity ifcmaterial definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param category + :type category:ifclabel + + :param hasrepresentation + :type hasrepresentation:SET(0,1,'ifcmaterialdefinitionrepresentation', scope = schema_scope) + + :param isrelatedwith + :type isrelatedwith:SET(0,None,'ifcmaterialrelationship', scope = schema_scope) + + :param relatesto + :type relatesto:SET(0,1,'ifcmaterialrelationship', scope = schema_scope) + ''' + def __init__( self , name,description,category, ): + ifcmaterialdefinition.__init__(self , ) + self.name = name + self.description = description + self.category = category + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def category(): + def fget( self ): + return self._category + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._category = ifclabel(value) + else: + self._category = value + else: + self._category = value + return property(**locals()) + + @apply + def hasrepresentation(): + def fget( self ): + return self._hasrepresentation + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasrepresentation is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isrelatedwith(): + def fget( self ): + return self._isrelatedwith + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isrelatedwith is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def relatesto(): + def fget( self ): + return self._relatesto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument relatesto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcmember # +#################### +class ifcmember(ifcbuildingelement): + '''Entity ifcmember definition. + + :param predefinedtype + :type predefinedtype:ifcmembertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmembertypeenum): + self._predefinedtype = ifcmembertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcmembertypeenum.self.userdefined)) or ((self.predefinedtype == ifcmembertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCMEMBERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcdistributioncontrolelement # +#################### +class ifcdistributioncontrolelement(ifcdistributionelement): + '''Entity ifcdistributioncontrolelement definition. + + :param assignedtoflowelement + :type assignedtoflowelement:SET(0,1,'ifcrelflowcontrolelements', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def assignedtoflowelement(): + def fget( self ): + return self._assignedtoflowelement + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument assignedtoflowelement is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcflowinstrument # +#################### +class ifcflowinstrument(ifcdistributioncontrolelement): + '''Entity ifcflowinstrument definition. + + :param predefinedtype + :type predefinedtype:ifcflowinstrumenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcdistributioncontrolelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcflowinstrumenttypeenum): + self._predefinedtype = ifcflowinstrumenttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcflowinstrumenttypeenum.self.userdefined)) or ((self.predefinedtype == ifcflowinstrumenttypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCFLOWINSTRUMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcenergyconversiondevice # +#################### +class ifcenergyconversiondevice(ifcdistributionflowelement): + '''Entity ifcenergyconversiondevice definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifchumidifier # +#################### +class ifchumidifier(ifcenergyconversiondevice): + '''Entity ifchumidifier definition. + + :param predefinedtype + :type predefinedtype:ifchumidifiertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifchumidifiertypeenum): + self._predefinedtype = ifchumidifiertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifchumidifiertypeenum.self.userdefined)) or ((self.predefinedtype == ifchumidifiertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCHUMIDIFIERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcgroup # +#################### +class ifcgroup(ifcobject): + '''Entity ifcgroup definition. + + :param isgroupedby + :type isgroupedby:SET(0,None,'ifcrelassignstogroup', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + + @apply + def isgroupedby(): + def fget( self ): + return self._isgroupedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isgroupedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsystem # +#################### +class ifcsystem(ifcgroup): + '''Entity ifcsystem definition. + + :param servicesbuildings + :type servicesbuildings:SET(0,1,'ifcrelservicesbuildings', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + + @apply + def servicesbuildings(): + def fget( self ): + return self._servicesbuildings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument servicesbuildings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcworkcalendar # +#################### +class ifcworkcalendar(ifccontrol): + '''Entity ifcworkcalendar definition. + + :param workingtimes + :type workingtimes:SET(1,None,'ifcworktime', scope = schema_scope) + + :param exceptiontimes + :type exceptiontimes:SET(1,None,'ifcworktime', scope = schema_scope) + + :param predefinedtype + :type predefinedtype:ifcworkcalendartypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , workingtimes,exceptiontimes,predefinedtype, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , ) + self.workingtimes = workingtimes + self.exceptiontimes = exceptiontimes + self.predefinedtype = predefinedtype + + @apply + def workingtimes(): + def fget( self ): + return self._workingtimes + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcworktime', scope = schema_scope)): + self._workingtimes = SET(value) + else: + self._workingtimes = value + else: + self._workingtimes = value + return property(**locals()) + + @apply + def exceptiontimes(): + def fget( self ): + return self._exceptiontimes + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcworktime', scope = schema_scope)): + self._exceptiontimes = SET(value) + else: + self._exceptiontimes = value + else: + self._exceptiontimes = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcworkcalendartypeenum): + self._predefinedtype = ifcworkcalendartypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcworkcalendartypeenum.self.userdefined)) or ((self.predefinedtype == ifcworkcalendartypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcannotationfillarea # +#################### +class ifcannotationfillarea(ifcgeometricrepresentationitem): + '''Entity ifcannotationfillarea definition. + + :param outerboundary + :type outerboundary:ifccurve + + :param innerboundaries + :type innerboundaries:SET(1,None,'ifccurve', scope = schema_scope) + ''' + def __init__( self , outerboundary,innerboundaries, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.outerboundary = outerboundary + self.innerboundaries = innerboundaries + + @apply + def outerboundary(): + def fget( self ): + return self._outerboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument outerboundary is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._outerboundary = ifccurve(value) + else: + self._outerboundary = value + return property(**locals()) + + @apply + def innerboundaries(): + def fget( self ): + return self._innerboundaries + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifccurve', scope = schema_scope)): + self._innerboundaries = SET(value) + else: + self._innerboundaries = value + else: + self._innerboundaries = value + return property(**locals()) + +#################### + # ENTITY ifcelementcomponenttype # +#################### +class ifcelementcomponenttype(ifcelementtype): + '''Entity ifcelementcomponenttype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcbuildingelementparttype # +#################### +class ifcbuildingelementparttype(ifcelementcomponenttype): + '''Entity ifcbuildingelementparttype definition. + + :param predefinedtype + :type predefinedtype:ifcbuildingelementparttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcelementcomponenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcbuildingelementparttypeenum): + self._predefinedtype = ifcbuildingelementparttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcbuildingelementparttypeenum.self.userdefined) or ((self.predefinedtype == ifcbuildingelementparttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcelectricmotor # +#################### +class ifcelectricmotor(ifcenergyconversiondevice): + '''Entity ifcelectricmotor definition. + + :param predefinedtype + :type predefinedtype:ifcelectricmotortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelectricmotortypeenum): + self._predefinedtype = ifcelectricmotortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcelectricmotortypeenum.self.userdefined)) or ((self.predefinedtype == ifcelectricmotortypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCELECTRICMOTORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcschedulingtime # +#################### +class ifcschedulingtime(BaseEntityClass): + '''Entity ifcschedulingtime definition. + + :param name + :type name:ifclabel + + :param dataorigin + :type dataorigin:ifcdataoriginenum + + :param userdefineddataorigin + :type userdefineddataorigin:ifclabel + ''' + def __init__( self , name,dataorigin,userdefineddataorigin, ): + self.name = name + self.dataorigin = dataorigin + self.userdefineddataorigin = userdefineddataorigin + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def dataorigin(): + def fget( self ): + return self._dataorigin + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdataoriginenum): + self._dataorigin = ifcdataoriginenum(value) + else: + self._dataorigin = value + else: + self._dataorigin = value + return property(**locals()) + + @apply + def userdefineddataorigin(): + def fget( self ): + return self._userdefineddataorigin + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefineddataorigin = ifclabel(value) + else: + self._userdefineddataorigin = value + else: + self._userdefineddataorigin = value + return property(**locals()) + +#################### + # ENTITY ifceventtime # +#################### +class ifceventtime(ifcschedulingtime): + '''Entity ifceventtime definition. + + :param actualdate + :type actualdate:ifcdatetime + + :param earlydate + :type earlydate:ifcdatetime + + :param latedate + :type latedate:ifcdatetime + + :param scheduledate + :type scheduledate:ifcdatetime + ''' + def __init__( self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , actualdate,earlydate,latedate,scheduledate, ): + ifcschedulingtime.__init__(self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , ) + self.actualdate = actualdate + self.earlydate = earlydate + self.latedate = latedate + self.scheduledate = scheduledate + + @apply + def actualdate(): + def fget( self ): + return self._actualdate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._actualdate = ifcdatetime(value) + else: + self._actualdate = value + else: + self._actualdate = value + return property(**locals()) + + @apply + def earlydate(): + def fget( self ): + return self._earlydate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._earlydate = ifcdatetime(value) + else: + self._earlydate = value + else: + self._earlydate = value + return property(**locals()) + + @apply + def latedate(): + def fget( self ): + return self._latedate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._latedate = ifcdatetime(value) + else: + self._latedate = value + else: + self._latedate = value + return property(**locals()) + + @apply + def scheduledate(): + def fget( self ): + return self._scheduledate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._scheduledate = ifcdatetime(value) + else: + self._scheduledate = value + else: + self._scheduledate = value + return property(**locals()) + +#################### + # ENTITY ifcactuator # +#################### +class ifcactuator(ifcdistributioncontrolelement): + '''Entity ifcactuator definition. + + :param predefinedtype + :type predefinedtype:ifcactuatortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcdistributioncontrolelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactuatortypeenum): + self._predefinedtype = ifcactuatortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcactuatortypeenum.self.userdefined)) or ((self.predefinedtype == ifcactuatortypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCACTUATORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcbuildingelementtype # +#################### +class ifcbuildingelementtype(ifcelementtype): + '''Entity ifcbuildingelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcstairtype # +#################### +class ifcstairtype(ifcbuildingelementtype): + '''Entity ifcstairtype definition. + + :param predefinedtype + :type predefinedtype:ifcstairtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstairtypeenum): + self._predefinedtype = ifcstairtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcstairtypeenum.self.userdefined) or ((self.predefinedtype == ifcstairtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpredefinedpropertyset # +#################### +class ifcpredefinedpropertyset(ifcpropertysetdefinition): + '''Entity ifcpredefinedpropertyset definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + +#################### + # ENTITY ifcdoorpanelproperties # +#################### +class ifcdoorpanelproperties(ifcpredefinedpropertyset): + '''Entity ifcdoorpanelproperties definition. + + :param paneldepth + :type paneldepth:ifcpositivelengthmeasure + + :param paneloperation + :type paneloperation:ifcdoorpaneloperationenum + + :param panelwidth + :type panelwidth:ifcnormalisedratiomeasure + + :param panelposition + :type panelposition:ifcdoorpanelpositionenum + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , paneldepth,paneloperation,panelwidth,panelposition,shapeaspectstyle, ): + ifcpredefinedpropertyset.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.paneldepth = paneldepth + self.paneloperation = paneloperation + self.panelwidth = panelwidth + self.panelposition = panelposition + self.shapeaspectstyle = shapeaspectstyle + + @apply + def paneldepth(): + def fget( self ): + return self._paneldepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._paneldepth = ifcpositivelengthmeasure(value) + else: + self._paneldepth = value + else: + self._paneldepth = value + return property(**locals()) + + @apply + def paneloperation(): + def fget( self ): + return self._paneloperation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument paneloperation is mantatory and can not be set to None') + if not check_type(value,ifcdoorpaneloperationenum): + self._paneloperation = ifcdoorpaneloperationenum(value) + else: + self._paneloperation = value + return property(**locals()) + + @apply + def panelwidth(): + def fget( self ): + return self._panelwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._panelwidth = ifcnormalisedratiomeasure(value) + else: + self._panelwidth = value + else: + self._panelwidth = value + return property(**locals()) + + @apply + def panelposition(): + def fget( self ): + return self._panelposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument panelposition is mantatory and can not be set to None') + if not check_type(value,ifcdoorpanelpositionenum): + self._panelposition = ifcdoorpanelpositionenum(value) + else: + self._panelposition = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + def applicabletotype(self): + eval_applicabletotype_wr = (EXISTS(self.self.ifcpropertysetdefinition.self.definestype[1]) and (('IFC4.IFCDOORTYPE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1])) or ('IFC4.IFCDOORSTYLE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1])))) + if not eval_applicabletotype_wr: + raise AssertionError('Rule applicabletotype violated') + else: + return eval_applicabletotype_wr + + +#################### + # ENTITY ifcpermeablecoveringproperties # +#################### +class ifcpermeablecoveringproperties(ifcpredefinedpropertyset): + '''Entity ifcpermeablecoveringproperties definition. + + :param operationtype + :type operationtype:ifcpermeablecoveringoperationenum + + :param panelposition + :type panelposition:ifcwindowpanelpositionenum + + :param framedepth + :type framedepth:ifcpositivelengthmeasure + + :param framethickness + :type framethickness:ifcpositivelengthmeasure + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , operationtype,panelposition,framedepth,framethickness,shapeaspectstyle, ): + ifcpredefinedpropertyset.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.operationtype = operationtype + self.panelposition = panelposition + self.framedepth = framedepth + self.framethickness = framethickness + self.shapeaspectstyle = shapeaspectstyle + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operationtype is mantatory and can not be set to None') + if not check_type(value,ifcpermeablecoveringoperationenum): + self._operationtype = ifcpermeablecoveringoperationenum(value) + else: + self._operationtype = value + return property(**locals()) + + @apply + def panelposition(): + def fget( self ): + return self._panelposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument panelposition is mantatory and can not be set to None') + if not check_type(value,ifcwindowpanelpositionenum): + self._panelposition = ifcwindowpanelpositionenum(value) + else: + self._panelposition = value + return property(**locals()) + + @apply + def framedepth(): + def fget( self ): + return self._framedepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._framedepth = ifcpositivelengthmeasure(value) + else: + self._framedepth = value + else: + self._framedepth = value + return property(**locals()) + + @apply + def framethickness(): + def fget( self ): + return self._framethickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._framethickness = ifcpositivelengthmeasure(value) + else: + self._framethickness = value + else: + self._framethickness = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + +#################### + # ENTITY ifccompositecurvesegment # +#################### +class ifccompositecurvesegment(ifcgeometricrepresentationitem): + '''Entity ifccompositecurvesegment definition. + + :param transition + :type transition:ifctransitioncode + + :param samesense + :type samesense:BOOLEAN + + :param parentcurve + :type parentcurve:ifccurve + + :param dim + :type dim:ifcdimensioncount + + :param usingcurves + :type usingcurves:SET(1,None,'ifccompositecurve', scope = schema_scope) + ''' + def __init__( self , transition,samesense,parentcurve, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.transition = transition + self.samesense = samesense + self.parentcurve = parentcurve + + @apply + def transition(): + def fget( self ): + return self._transition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transition is mantatory and can not be set to None') + if not check_type(value,ifctransitioncode): + self._transition = ifctransitioncode(value) + else: + self._transition = value + return property(**locals()) + + @apply + def samesense(): + def fget( self ): + return self._samesense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument samesense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._samesense = BOOLEAN(value) + else: + self._samesense = value + return property(**locals()) + + @apply + def parentcurve(): + def fget( self ): + return self._parentcurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parentcurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._parentcurve = ifccurve(value) + else: + self._parentcurve = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.parentcurve.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def usingcurves(): + def fget( self ): + return self._usingcurves + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument usingcurves is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def parentisboundedcurve(self): + eval_parentisboundedcurve_wr = ('IFC4.IFCBOUNDEDCURVE' == TYPEOF(self.parentcurve)) + if not eval_parentisboundedcurve_wr: + raise AssertionError('Rule parentisboundedcurve violated') + else: + return eval_parentisboundedcurve_wr + + +#################### + # ENTITY ifcreparametrisedcompositecurvesegment # +#################### +class ifcreparametrisedcompositecurvesegment(ifccompositecurvesegment): + '''Entity ifcreparametrisedcompositecurvesegment definition. + + :param paramlength + :type paramlength:ifcparametervalue + ''' + def __init__( self , inherited0__transition , inherited1__samesense , inherited2__parentcurve , paramlength, ): + ifccompositecurvesegment.__init__(self , inherited0__transition , inherited1__samesense , inherited2__parentcurve , ) + self.paramlength = paramlength + + @apply + def paramlength(): + def fget( self ): + return self._paramlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument paramlength is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._paramlength = ifcparametervalue(value) + else: + self._paramlength = value + return property(**locals()) + def positivelengthparameter(self): + eval_positivelengthparameter_wr = (self.paramlength > 0) + if not eval_positivelengthparameter_wr: + raise AssertionError('Rule positivelengthparameter violated') + else: + return eval_positivelengthparameter_wr + + +#################### + # ENTITY ifccurve # +#################### +class ifccurve(ifcgeometricrepresentationitem): + '''Entity ifccurve definition. + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + + @apply + def dim(): + def fget( self ): + attribute_eval = ifccurvedim(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcboundedcurve # +#################### +class ifcboundedcurve(ifccurve): + '''Entity ifcboundedcurve definition. + ''' + def __init__( self , ): + ifccurve.__init__(self , ) + +#################### + # ENTITY ifcbsplinecurve # +#################### +class ifcbsplinecurve(ifcboundedcurve): + '''Entity ifcbsplinecurve definition. + + :param degree + :type degree:INTEGER + + :param controlpointslist + :type controlpointslist:LIST(2,None,'ifccartesianpoint', scope = schema_scope) + + :param curveform + :type curveform:ifcbsplinecurveform + + :param closedcurve + :type closedcurve:LOGICAL + + :param selfintersect + :type selfintersect:LOGICAL + + :param upperindexoncontrolpoints + :type upperindexoncontrolpoints:INTEGER + + :param controlpoints + :type controlpoints:ARRAY(0,upperindexoncontrolpoints,'ifccartesianpoint', scope = schema_scope) + ''' + def __init__( self , degree,controlpointslist,curveform,closedcurve,selfintersect, ): + ifcboundedcurve.__init__(self , ) + self.degree = degree + self.controlpointslist = controlpointslist + self.curveform = curveform + self.closedcurve = closedcurve + self.selfintersect = selfintersect + + @apply + def degree(): + def fget( self ): + return self._degree + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument degree is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._degree = INTEGER(value) + else: + self._degree = value + return property(**locals()) + + @apply + def controlpointslist(): + def fget( self ): + return self._controlpointslist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument controlpointslist is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'ifccartesianpoint', scope = schema_scope)): + self._controlpointslist = LIST(value) + else: + self._controlpointslist = value + return property(**locals()) + + @apply + def curveform(): + def fget( self ): + return self._curveform + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curveform is mantatory and can not be set to None') + if not check_type(value,ifcbsplinecurveform): + self._curveform = ifcbsplinecurveform(value) + else: + self._curveform = value + return property(**locals()) + + @apply + def closedcurve(): + def fget( self ): + return self._closedcurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument closedcurve is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._closedcurve = LOGICAL(value) + else: + self._closedcurve = value + return property(**locals()) + + @apply + def selfintersect(): + def fget( self ): + return self._selfintersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument selfintersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._selfintersect = LOGICAL(value) + else: + self._selfintersect = value + return property(**locals()) + + @apply + def upperindexoncontrolpoints(): + def fget( self ): + attribute_eval = (SIZEOF(self.controlpointslist) - 1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument upperindexoncontrolpoints is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def controlpoints(): + def fget( self ): + attribute_eval = ifclisttoarray(self.controlpointslist,0,self.upperindexoncontrolpoints) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument controlpoints is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def samedim(self): + eval_samedim_wr = (SIZEOF(None) == 0) + if not eval_samedim_wr: + raise AssertionError('Rule samedim violated') + else: + return eval_samedim_wr + + +#################### + # ENTITY ifcstructuralaction # +#################### +class ifcstructuralaction(ifcstructuralactivity): + '''Entity ifcstructuralaction definition. + + :param destabilizingload + :type destabilizingload:BOOLEAN + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , destabilizingload, ): + ifcstructuralactivity.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ) + self.destabilizingload = destabilizingload + + @apply + def destabilizingload(): + def fget( self ): + return self._destabilizingload + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._destabilizingload = BOOLEAN(value) + else: + self._destabilizingload = value + else: + self._destabilizingload = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralsurfaceaction # +#################### +class ifcstructuralsurfaceaction(ifcstructuralaction): + '''Entity ifcstructuralsurfaceaction definition. + + :param projectedortrue + :type projectedortrue:ifcprojectedortruelengthenum + + :param predefinedtype + :type predefinedtype:ifcstructuralsurfaceactivitytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , projectedortrue,predefinedtype, ): + ifcstructuralaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , ) + self.projectedortrue = projectedortrue + self.predefinedtype = predefinedtype + + @apply + def projectedortrue(): + def fget( self ): + return self._projectedortrue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcprojectedortruelengthenum): + self._projectedortrue = ifcprojectedortruelengthenum(value) + else: + self._projectedortrue = value + else: + self._projectedortrue = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstructuralsurfaceactivitytypeenum): + self._predefinedtype = ifcstructuralsurfaceactivitytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def projectedisglobal(self): + eval_projectedisglobal_wr = (( not EXISTS(self.projectedortrue)) or ((self.projectedortrue != projected_length) or (self.self.ifcstructuralactivity.self.globalorlocal == global_coords))) + if not eval_projectedisglobal_wr: + raise AssertionError('Rule projectedisglobal violated') + else: + return eval_projectedisglobal_wr + + def hasobjecttype(self): + eval_hasobjecttype_wr = ((self.predefinedtype != ifcstructuralsurfaceactivitytypeenum.self.userdefined) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + +#################### + # ENTITY ifcflowcontrollertype # +#################### +class ifcflowcontrollertype(ifcdistributionflowelementtype): + '''Entity ifcflowcontrollertype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcvalvetype # +#################### +class ifcvalvetype(ifcflowcontrollertype): + '''Entity ifcvalvetype definition. + + :param predefinedtype + :type predefinedtype:ifcvalvetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcvalvetypeenum): + self._predefinedtype = ifcvalvetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcvalvetypeenum.self.userdefined) or ((self.predefinedtype == ifcvalvetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcsweptareasolid # +#################### +class ifcsweptareasolid(ifcsolidmodel): + '''Entity ifcsweptareasolid definition. + + :param sweptarea + :type sweptarea:ifcprofiledef + + :param position + :type position:ifcaxis2placement3d + ''' + def __init__( self , sweptarea,position, ): + ifcsolidmodel.__init__(self , ) + self.sweptarea = sweptarea + self.position = position + + @apply + def sweptarea(): + def fget( self ): + return self._sweptarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sweptarea is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._sweptarea = ifcprofiledef(value) + else: + self._sweptarea = value + return property(**locals()) + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + else: + self._position = value + return property(**locals()) + def sweptareatype(self): + eval_sweptareatype_wr = (self.sweptarea.self.profiletype == ifcprofiletypeenum.self.area) + if not eval_sweptareatype_wr: + raise AssertionError('Rule sweptareatype violated') + else: + return eval_sweptareatype_wr + + +#################### + # ENTITY ifcrevolvedareasolid # +#################### +class ifcrevolvedareasolid(ifcsweptareasolid): + '''Entity ifcrevolvedareasolid definition. + + :param axis + :type axis:ifcaxis1placement + + :param angle + :type angle:ifcplaneanglemeasure + + :param axisline + :type axisline:ifcline + ''' + def __init__( self , inherited0__sweptarea , inherited1__position , axis,angle, ): + ifcsweptareasolid.__init__(self , inherited0__sweptarea , inherited1__position , ) + self.axis = axis + self.angle = angle + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axis is mantatory and can not be set to None') + if not check_type(value,ifcaxis1placement): + self._axis = ifcaxis1placement(value) + else: + self._axis = value + return property(**locals()) + + @apply + def angle(): + def fget( self ): + return self._angle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument angle is mantatory and can not be set to None') + if not check_type(value,ifcplaneanglemeasure): + self._angle = ifcplaneanglemeasure(value) + else: + self._angle = value + return property(**locals()) + + @apply + def axisline(): + def fget( self ): + attribute_eval = (((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifccurve()) == ifcline(self.axis.self.location,(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(self.axis.self.z,1))) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument axisline is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def axisstartinxy(self): + eval_axisstartinxy_wr = (self.axis.self.location.self.coordinates[3] == 0) + if not eval_axisstartinxy_wr: + raise AssertionError('Rule axisstartinxy violated') + else: + return eval_axisstartinxy_wr + + def axisdirectioninxy(self): + eval_axisdirectioninxy_wr = (self.axis.self.z.self.directionratios[3] == 0) + if not eval_axisdirectioninxy_wr: + raise AssertionError('Rule axisdirectioninxy violated') + else: + return eval_axisdirectioninxy_wr + + +#################### + # ENTITY ifctexturecoordinate # +#################### +class ifctexturecoordinate(ifcpresentationitem): + '''Entity ifctexturecoordinate definition. + + :param maps + :type maps:LIST(1,None,'ifcsurfacetexture', scope = schema_scope) + ''' + def __init__( self , maps, ): + ifcpresentationitem.__init__(self , ) + self.maps = maps + + @apply + def maps(): + def fget( self ): + return self._maps + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument maps is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcsurfacetexture', scope = schema_scope)): + self._maps = LIST(value) + else: + self._maps = value + return property(**locals()) + +#################### + # ENTITY ifctexturemap # +#################### +class ifctexturemap(ifctexturecoordinate): + '''Entity ifctexturemap definition. + + :param vertices + :type vertices:LIST(3,None,'ifctexturevertex', scope = schema_scope) + + :param mappedto + :type mappedto:ifcface + ''' + def __init__( self , inherited0__maps , vertices,mappedto, ): + ifctexturecoordinate.__init__(self , inherited0__maps , ) + self.vertices = vertices + self.mappedto = mappedto + + @apply + def vertices(): + def fget( self ): + return self._vertices + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vertices is mantatory and can not be set to None') + if not check_type(value,LIST(3,None,'ifctexturevertex', scope = schema_scope)): + self._vertices = LIST(value) + else: + self._vertices = value + return property(**locals()) + + @apply + def mappedto(): + def fget( self ): + return self._mappedto + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappedto is mantatory and can not be set to None') + if not check_type(value,ifcface): + self._mappedto = ifcface(value) + else: + self._mappedto = value + return property(**locals()) + +#################### + # ENTITY ifcairterminalboxtype # +#################### +class ifcairterminalboxtype(ifcflowcontrollertype): + '''Entity ifcairterminalboxtype definition. + + :param predefinedtype + :type predefinedtype:ifcairterminalboxtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcairterminalboxtypeenum): + self._predefinedtype = ifcairterminalboxtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcairterminalboxtypeenum.self.userdefined) or ((self.predefinedtype == ifcairterminalboxtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcboundarycondition # +#################### +class ifcboundarycondition(BaseEntityClass): + '''Entity ifcboundarycondition definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcbuildingelementproxytype # +#################### +class ifcbuildingelementproxytype(ifcbuildingelementtype): + '''Entity ifcbuildingelementproxytype definition. + + :param predefinedtype + :type predefinedtype:ifcbuildingelementproxytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcbuildingelementproxytypeenum): + self._predefinedtype = ifcbuildingelementproxytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcbuildingelementproxytypeenum.self.userdefined) or ((self.predefinedtype == ifcbuildingelementproxytypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpresentationstyle # +#################### +class ifcpresentationstyle(BaseEntityClass): + '''Entity ifcpresentationstyle definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifcfillareastyle # +#################### +class ifcfillareastyle(ifcpresentationstyle): + '''Entity ifcfillareastyle definition. + + :param fillstyles + :type fillstyles:SET(1,None,'ifcfillstyleselect', scope = schema_scope) + + :param modelordraughting + :type modelordraughting:BOOLEAN + ''' + def __init__( self , inherited0__name , fillstyles,modelordraughting, ): + ifcpresentationstyle.__init__(self , inherited0__name , ) + self.fillstyles = fillstyles + self.modelordraughting = modelordraughting + + @apply + def fillstyles(): + def fget( self ): + return self._fillstyles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fillstyles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcfillstyleselect', scope = schema_scope)): + self._fillstyles = SET(value) + else: + self._fillstyles = value + return property(**locals()) + + @apply + def modelordraughting(): + def fget( self ): + return self._modelordraughting + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._modelordraughting = BOOLEAN(value) + else: + self._modelordraughting = value + else: + self._modelordraughting = value + return property(**locals()) + def maxonecolour(self): + eval_maxonecolour_wr = (SIZEOF(None) <= 1) + if not eval_maxonecolour_wr: + raise AssertionError('Rule maxonecolour violated') + else: + return eval_maxonecolour_wr + + def maxoneexthatchstyle(self): + eval_maxoneexthatchstyle_wr = (SIZEOF(None) <= 1) + if not eval_maxoneexthatchstyle_wr: + raise AssertionError('Rule maxoneexthatchstyle violated') + else: + return eval_maxoneexthatchstyle_wr + + def consistenthatchstyledef(self): + eval_consistenthatchstyledef_wr = ifccorrectfillareastyle(self.self.fillstyles) + if not eval_consistenthatchstyledef_wr: + raise AssertionError('Rule consistenthatchstyledef violated') + else: + return eval_consistenthatchstyledef_wr + + +#################### + # ENTITY ifccsgsolid # +#################### +class ifccsgsolid(ifcsolidmodel): + '''Entity ifccsgsolid definition. + + :param treerootexpression + :type treerootexpression:ifccsgselect + ''' + def __init__( self , treerootexpression, ): + ifcsolidmodel.__init__(self , ) + self.treerootexpression = treerootexpression + + @apply + def treerootexpression(): + def fget( self ): + return self._treerootexpression + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument treerootexpression is mantatory and can not be set to None') + if not check_type(value,ifccsgselect): + self._treerootexpression = ifccsgselect(value) + else: + self._treerootexpression = value + return property(**locals()) + +#################### + # ENTITY ifcfurnishingelement # +#################### +class ifcfurnishingelement(ifcelement): + '''Entity ifcfurnishingelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcfurniture # +#################### +class ifcfurniture(ifcfurnishingelement): + '''Entity ifcfurniture definition. + + :param predefinedtype + :type predefinedtype:ifcfurnituretypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcfurnishingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfurnituretypeenum): + self._predefinedtype = ifcfurnituretypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcfurnituretypeenum.self.userdefined)) or ((self.predefinedtype == ifcfurnituretypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCFURNITURETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcsurfacetexture # +#################### +class ifcsurfacetexture(ifcpresentationitem): + '''Entity ifcsurfacetexture definition. + + :param repeats + :type repeats:BOOLEAN + + :param repeatt + :type repeatt:BOOLEAN + + :param mode + :type mode:ifcidentifier + + :param texturetransform + :type texturetransform:ifccartesiantransformationoperator2d + + :param parameter + :type parameter:LIST(1,None,'STRING', scope = schema_scope) + + :param ismappedby + :type ismappedby:SET(0,None,'ifctexturecoordinate', scope = schema_scope) + + :param usedinstyles + :type usedinstyles:SET(0,None,'ifcsurfacestylewithtextures', scope = schema_scope) + ''' + def __init__( self , repeats,repeatt,mode,texturetransform,parameter, ): + ifcpresentationitem.__init__(self , ) + self.repeats = repeats + self.repeatt = repeatt + self.mode = mode + self.texturetransform = texturetransform + self.parameter = parameter + + @apply + def repeats(): + def fget( self ): + return self._repeats + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument repeats is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._repeats = BOOLEAN(value) + else: + self._repeats = value + return property(**locals()) + + @apply + def repeatt(): + def fget( self ): + return self._repeatt + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument repeatt is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._repeatt = BOOLEAN(value) + else: + self._repeatt = value + return property(**locals()) + + @apply + def mode(): + def fget( self ): + return self._mode + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._mode = ifcidentifier(value) + else: + self._mode = value + else: + self._mode = value + return property(**locals()) + + @apply + def texturetransform(): + def fget( self ): + return self._texturetransform + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccartesiantransformationoperator2d): + self._texturetransform = ifccartesiantransformationoperator2d(value) + else: + self._texturetransform = value + else: + self._texturetransform = value + return property(**locals()) + + @apply + def parameter(): + def fget( self ): + return self._parameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._parameter = LIST(value) + else: + self._parameter = value + else: + self._parameter = value + return property(**locals()) + + @apply + def ismappedby(): + def fget( self ): + return self._ismappedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ismappedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def usedinstyles(): + def fget( self ): + return self._usedinstyles + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument usedinstyles is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcpixeltexture # +#################### +class ifcpixeltexture(ifcsurfacetexture): + '''Entity ifcpixeltexture definition. + + :param width + :type width:ifcinteger + + :param height + :type height:ifcinteger + + :param colourcomponents + :type colourcomponents:ifcinteger + + :param pixel + :type pixel:LIST(1,None,'(null)', scope = schema_scope) + ''' + def __init__( self , inherited0__repeats , inherited1__repeatt , inherited2__mode , inherited3__texturetransform , inherited4__parameter , width,height,colourcomponents,pixel, ): + ifcsurfacetexture.__init__(self , inherited0__repeats , inherited1__repeatt , inherited2__mode , inherited3__texturetransform , inherited4__parameter , ) + self.width = width + self.height = height + self.colourcomponents = colourcomponents + self.pixel = pixel + + @apply + def width(): + def fget( self ): + return self._width + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument width is mantatory and can not be set to None') + if not check_type(value,ifcinteger): + self._width = ifcinteger(value) + else: + self._width = value + return property(**locals()) + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,ifcinteger): + self._height = ifcinteger(value) + else: + self._height = value + return property(**locals()) + + @apply + def colourcomponents(): + def fget( self ): + return self._colourcomponents + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colourcomponents is mantatory and can not be set to None') + if not check_type(value,ifcinteger): + self._colourcomponents = ifcinteger(value) + else: + self._colourcomponents = value + return property(**locals()) + + @apply + def pixel(): + def fget( self ): + return self._pixel + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pixel is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'(null)', scope = schema_scope)): + self._pixel = LIST(value) + else: + self._pixel = value + return property(**locals()) + def minpixelins(self): + eval_minpixelins_wr = (self.width >= 1) + if not eval_minpixelins_wr: + raise AssertionError('Rule minpixelins violated') + else: + return eval_minpixelins_wr + + def minpixelint(self): + eval_minpixelint_wr = (self.height >= 1) + if not eval_minpixelint_wr: + raise AssertionError('Rule minpixelint violated') + else: + return eval_minpixelint_wr + + def numberofcolours(self): + eval_numberofcolours_wr = ((1 <= self.colourcomponents) and (self.colourcomponents <= 4)) + if not eval_numberofcolours_wr: + raise AssertionError('Rule numberofcolours violated') + else: + return eval_numberofcolours_wr + + def sizeofpixellist(self): + eval_sizeofpixellist_wr = (SIZEOF(self.pixel) == (self.width * self.height)) + if not eval_sizeofpixellist_wr: + raise AssertionError('Rule sizeofpixellist violated') + else: + return eval_sizeofpixellist_wr + + def pixelasbyteandsamelength(self): + eval_pixelasbyteandsamelength_wr = (SIZEOF(None) == SIZEOF(self.pixel)) + if not eval_pixelasbyteandsamelength_wr: + raise AssertionError('Rule pixelasbyteandsamelength violated') + else: + return eval_pixelasbyteandsamelength_wr + + +#################### + # ENTITY ifctypeprocess # +#################### +class ifctypeprocess(ifctypeobject): + '''Entity ifctypeprocess definition. + + :param identification + :type identification:ifcidentifier + + :param longdescription + :type longdescription:ifctext + + :param processtype + :type processtype:ifclabel + + :param operateson + :type operateson:SET(0,None,'ifcrelassignstoprocess', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , identification,longdescription,processtype, ): + ifctypeobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , ) + self.identification = identification + self.longdescription = longdescription + self.processtype = processtype + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + else: + self._identification = value + return property(**locals()) + + @apply + def longdescription(): + def fget( self ): + return self._longdescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._longdescription = ifctext(value) + else: + self._longdescription = value + else: + self._longdescription = value + return property(**locals()) + + @apply + def processtype(): + def fget( self ): + return self._processtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._processtype = ifclabel(value) + else: + self._processtype = value + else: + self._processtype = value + return property(**locals()) + + @apply + def operateson(): + def fget( self ): + return self._operateson + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument operateson is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcrelassociates # +#################### +class ifcrelassociates(ifcrelationship): + '''Entity ifcrelassociates definition. + + :param relatedobjects + :type relatedobjects:SET(1,None,'ifcdefinitionselect', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedobjects, ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedobjects = relatedobjects + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcdefinitionselect', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + +#################### + # ENTITY ifcreldecomposes # +#################### +class ifcreldecomposes(ifcrelationship): + '''Entity ifcreldecomposes definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + +#################### + # ENTITY ifcrelnests # +#################### +class ifcrelnests(ifcreldecomposes): + '''Entity ifcrelnests definition. + + :param relatingobject + :type relatingobject:ifcobjectdefinition + + :param relatedobjects + :type relatedobjects:LIST(1,None,'ifcobjectdefinition', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingobject,relatedobjects, ): + ifcreldecomposes.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingobject = relatingobject + self.relatedobjects = relatedobjects + + @apply + def relatingobject(): + def fget( self ): + return self._relatingobject + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingobject is mantatory and can not be set to None') + if not check_type(value,ifcobjectdefinition): + self._relatingobject = ifcobjectdefinition(value) + else: + self._relatingobject = value + return property(**locals()) + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcobjectdefinition', scope = schema_scope)): + self._relatedobjects = LIST(value) + else: + self._relatedobjects = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcspatialelementtype # +#################### +class ifcspatialelementtype(ifctypeproduct): + '''Entity ifcspatialelementtype definition. + + :param elementtype + :type elementtype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , elementtype, ): + ifctypeproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , ) + self.elementtype = elementtype + + @apply + def elementtype(): + def fget( self ): + return self._elementtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._elementtype = ifclabel(value) + else: + self._elementtype = value + else: + self._elementtype = value + return property(**locals()) + +#################### + # ENTITY ifcspatialstructureelementtype # +#################### +class ifcspatialstructureelementtype(ifcspatialelementtype): + '''Entity ifcspatialstructureelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcspatialelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcspacetype # +#################### +class ifcspacetype(ifcspatialstructureelementtype): + '''Entity ifcspacetype definition. + + :param predefinedtype + :type predefinedtype:ifcspacetypeenum + + :param longname + :type longname:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype,longname, ): + ifcspatialstructureelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + self.longname = longname + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcspacetypeenum): + self._predefinedtype = ifcspacetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def longname(): + def fget( self ): + return self._longname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._longname = ifclabel(value) + else: + self._longname = value + else: + self._longname = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcspacetypeenum.self.userdefined) or ((self.predefinedtype == ifcspacetypeenum.self.userdefined) and EXISTS(self.self.ifcspatialelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcplacement # +#################### +class ifcplacement(ifcgeometricrepresentationitem): + '''Entity ifcplacement definition. + + :param location + :type location:ifccartesianpoint + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , location, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.location = location + + @apply + def location(): + def fget( self ): + return self._location + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument location is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._location = ifccartesianpoint(value) + else: + self._location = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.location.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcaxis1placement # +#################### +class ifcaxis1placement(ifcplacement): + '''Entity ifcaxis1placement definition. + + :param axis + :type axis:ifcdirection + + :param z + :type z:ifcdirection + ''' + def __init__( self , inherited0__location , axis, ): + ifcplacement.__init__(self , inherited0__location , ) + self.axis = axis + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis = ifcdirection(value) + else: + self._axis = value + else: + self._axis = value + return property(**locals()) + + @apply + def z(): + def fget( self ): + attribute_eval = NVL(ifcnormalise(self.axis),(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,0,1])) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument z is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def axisis3d(self): + eval_axisis3d_wr = (( not EXISTS(self.axis)) or (self.axis.self.dim == 3)) + if not eval_axisis3d_wr: + raise AssertionError('Rule axisis3d violated') + else: + return eval_axisis3d_wr + + def locationis3d(self): + eval_locationis3d_wr = (self.self.ifcplacement.self.location.self.dim == 3) + if not eval_locationis3d_wr: + raise AssertionError('Rule locationis3d violated') + else: + return eval_locationis3d_wr + + +#################### + # ENTITY ifcflowfitting # +#################### +class ifcflowfitting(ifcdistributionflowelement): + '''Entity ifcflowfitting definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifccablecarrierfitting # +#################### +class ifccablecarrierfitting(ifcflowfitting): + '''Entity ifccablecarrierfitting definition. + + :param predefinedtype + :type predefinedtype:ifccablecarrierfittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowfitting.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccablecarrierfittingtypeenum): + self._predefinedtype = ifccablecarrierfittingtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccablecarrierfittingtypeenum.self.userdefined)) or ((self.predefinedtype == ifccablecarrierfittingtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCABLECARRIERFITTINGTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcelectricgeneratortype # +#################### +class ifcelectricgeneratortype(ifcenergyconversiondevicetype): + '''Entity ifcelectricgeneratortype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricgeneratortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricgeneratortypeenum): + self._predefinedtype = ifcelectricgeneratortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcelectricgeneratortypeenum.self.userdefined) or ((self.predefinedtype == ifcelectricgeneratortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcflowfittingtype # +#################### +class ifcflowfittingtype(ifcdistributionflowelementtype): + '''Entity ifcflowfittingtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcpipefittingtype # +#################### +class ifcpipefittingtype(ifcflowfittingtype): + '''Entity ifcpipefittingtype definition. + + :param predefinedtype + :type predefinedtype:ifcpipefittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowfittingtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcpipefittingtypeenum): + self._predefinedtype = ifcpipefittingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcpipefittingtypeenum.self.userdefined) or ((self.predefinedtype == ifcpipefittingtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcindexedcolourmap # +#################### +class ifcindexedcolourmap(ifcpresentationitem): + '''Entity ifcindexedcolourmap definition. + + :param mappedto + :type mappedto:ifctessellatedfaceset + + :param overrides + :type overrides:ifcsurfacestyleshading + + :param colours + :type colours:ifccolourrgblist + + :param colourindex + :type colourindex:LIST(1,None,'INTEGER', scope = schema_scope) + ''' + def __init__( self , mappedto,overrides,colours,colourindex, ): + ifcpresentationitem.__init__(self , ) + self.mappedto = mappedto + self.overrides = overrides + self.colours = colours + self.colourindex = colourindex + + @apply + def mappedto(): + def fget( self ): + return self._mappedto + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappedto is mantatory and can not be set to None') + if not check_type(value,ifctessellatedfaceset): + self._mappedto = ifctessellatedfaceset(value) + else: + self._mappedto = value + return property(**locals()) + + @apply + def overrides(): + def fget( self ): + return self._overrides + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsurfacestyleshading): + self._overrides = ifcsurfacestyleshading(value) + else: + self._overrides = value + else: + self._overrides = value + return property(**locals()) + + @apply + def colours(): + def fget( self ): + return self._colours + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colours is mantatory and can not be set to None') + if not check_type(value,ifccolourrgblist): + self._colours = ifccolourrgblist(value) + else: + self._colours = value + return property(**locals()) + + @apply + def colourindex(): + def fget( self ): + return self._colourindex + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colourindex is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'INTEGER', scope = schema_scope)): + self._colourindex = LIST(value) + else: + self._colourindex = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralconnection # +#################### +class ifcstructuralconnection(ifcstructuralitem): + '''Entity ifcstructuralconnection definition. + + :param appliedcondition + :type appliedcondition:ifcboundarycondition + + :param connectsstructuralmembers + :type connectsstructuralmembers:SET(1,None,'ifcrelconnectsstructuralmember', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , appliedcondition, ): + ifcstructuralitem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.appliedcondition = appliedcondition + + @apply + def appliedcondition(): + def fget( self ): + return self._appliedcondition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcboundarycondition): + self._appliedcondition = ifcboundarycondition(value) + else: + self._appliedcondition = value + else: + self._appliedcondition = value + return property(**locals()) + + @apply + def connectsstructuralmembers(): + def fget( self ): + return self._connectsstructuralmembers + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectsstructuralmembers is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcflowterminaltype # +#################### +class ifcflowterminaltype(ifcdistributionflowelementtype): + '''Entity ifcflowterminaltype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcwasteterminaltype # +#################### +class ifcwasteterminaltype(ifcflowterminaltype): + '''Entity ifcwasteterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcwasteterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcwasteterminaltypeenum): + self._predefinedtype = ifcwasteterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcwasteterminaltypeenum.self.userdefined) or ((self.predefinedtype == ifcwasteterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcfastenertype # +#################### +class ifcfastenertype(ifcelementcomponenttype): + '''Entity ifcfastenertype definition. + + :param predefinedtype + :type predefinedtype:ifcfastenertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcelementcomponenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcfastenertypeenum): + self._predefinedtype = ifcfastenertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcfastenertypeenum.self.userdefined) or ((self.predefinedtype == ifcfastenertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifclamptype # +#################### +class ifclamptype(ifcflowterminaltype): + '''Entity ifclamptype definition. + + :param predefinedtype + :type predefinedtype:ifclamptypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifclamptypeenum): + self._predefinedtype = ifclamptypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifclamptypeenum.self.userdefined) or ((self.predefinedtype == ifclamptypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpredefineditem # +#################### +class ifcpredefineditem(ifcpresentationitem): + '''Entity ifcpredefineditem definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + ifcpresentationitem.__init__(self , ) + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifctrimmedcurve # +#################### +class ifctrimmedcurve(ifcboundedcurve): + '''Entity ifctrimmedcurve definition. + + :param basiscurve + :type basiscurve:ifccurve + + :param trim1 + :type trim1:SET(1,2,'ifctrimmingselect', scope = schema_scope) + + :param trim2 + :type trim2:SET(1,2,'ifctrimmingselect', scope = schema_scope) + + :param senseagreement + :type senseagreement:BOOLEAN + + :param masterrepresentation + :type masterrepresentation:ifctrimmingpreference + ''' + def __init__( self , basiscurve,trim1,trim2,senseagreement,masterrepresentation, ): + ifcboundedcurve.__init__(self , ) + self.basiscurve = basiscurve + self.trim1 = trim1 + self.trim2 = trim2 + self.senseagreement = senseagreement + self.masterrepresentation = masterrepresentation + + @apply + def basiscurve(): + def fget( self ): + return self._basiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._basiscurve = ifccurve(value) + else: + self._basiscurve = value + return property(**locals()) + + @apply + def trim1(): + def fget( self ): + return self._trim1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument trim1 is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'ifctrimmingselect', scope = schema_scope)): + self._trim1 = SET(value) + else: + self._trim1 = value + return property(**locals()) + + @apply + def trim2(): + def fget( self ): + return self._trim2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument trim2 is mantatory and can not be set to None') + if not check_type(value,SET(1,2,'ifctrimmingselect', scope = schema_scope)): + self._trim2 = SET(value) + else: + self._trim2 = value + return property(**locals()) + + @apply + def senseagreement(): + def fget( self ): + return self._senseagreement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument senseagreement is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._senseagreement = BOOLEAN(value) + else: + self._senseagreement = value + return property(**locals()) + + @apply + def masterrepresentation(): + def fget( self ): + return self._masterrepresentation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument masterrepresentation is mantatory and can not be set to None') + if not check_type(value,ifctrimmingpreference): + self._masterrepresentation = ifctrimmingpreference(value) + else: + self._masterrepresentation = value + return property(**locals()) + def trim1valuesconsistent(self): + eval_trim1valuesconsistent_wr = ((HIINDEX(self.trim1) == 1) or (TYPEOF(self.trim1[1]) != TYPEOF(self.trim1[2]))) + if not eval_trim1valuesconsistent_wr: + raise AssertionError('Rule trim1valuesconsistent violated') + else: + return eval_trim1valuesconsistent_wr + + def trim2valuesconsistent(self): + eval_trim2valuesconsistent_wr = ((HIINDEX(self.trim2) == 1) or (TYPEOF(self.trim2[1]) != TYPEOF(self.trim2[2]))) + if not eval_trim2valuesconsistent_wr: + raise AssertionError('Rule trim2valuesconsistent violated') + else: + return eval_trim2valuesconsistent_wr + + def notrimofboundedcurves(self): + eval_notrimofboundedcurves_wr = ( not ('IFC4.IFCBOUNDEDCURVE' == TYPEOF(self.basiscurve))) + if not eval_notrimofboundedcurves_wr: + raise AssertionError('Rule notrimofboundedcurves violated') + else: + return eval_notrimofboundedcurves_wr + + +#################### + # ENTITY ifcboundarynodecondition # +#################### +class ifcboundarynodecondition(ifcboundarycondition): + '''Entity ifcboundarynodecondition definition. + + :param translationalstiffnessx + :type translationalstiffnessx:ifctranslationalstiffnessselect + + :param translationalstiffnessy + :type translationalstiffnessy:ifctranslationalstiffnessselect + + :param translationalstiffnessz + :type translationalstiffnessz:ifctranslationalstiffnessselect + + :param rotationalstiffnessx + :type rotationalstiffnessx:ifcrotationalstiffnessselect + + :param rotationalstiffnessy + :type rotationalstiffnessy:ifcrotationalstiffnessselect + + :param rotationalstiffnessz + :type rotationalstiffnessz:ifcrotationalstiffnessselect + ''' + def __init__( self , inherited0__name , translationalstiffnessx,translationalstiffnessy,translationalstiffnessz,rotationalstiffnessx,rotationalstiffnessy,rotationalstiffnessz, ): + ifcboundarycondition.__init__(self , inherited0__name , ) + self.translationalstiffnessx = translationalstiffnessx + self.translationalstiffnessy = translationalstiffnessy + self.translationalstiffnessz = translationalstiffnessz + self.rotationalstiffnessx = rotationalstiffnessx + self.rotationalstiffnessy = rotationalstiffnessy + self.rotationalstiffnessz = rotationalstiffnessz + + @apply + def translationalstiffnessx(): + def fget( self ): + return self._translationalstiffnessx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctranslationalstiffnessselect): + self._translationalstiffnessx = ifctranslationalstiffnessselect(value) + else: + self._translationalstiffnessx = value + else: + self._translationalstiffnessx = value + return property(**locals()) + + @apply + def translationalstiffnessy(): + def fget( self ): + return self._translationalstiffnessy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctranslationalstiffnessselect): + self._translationalstiffnessy = ifctranslationalstiffnessselect(value) + else: + self._translationalstiffnessy = value + else: + self._translationalstiffnessy = value + return property(**locals()) + + @apply + def translationalstiffnessz(): + def fget( self ): + return self._translationalstiffnessz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctranslationalstiffnessselect): + self._translationalstiffnessz = ifctranslationalstiffnessselect(value) + else: + self._translationalstiffnessz = value + else: + self._translationalstiffnessz = value + return property(**locals()) + + @apply + def rotationalstiffnessx(): + def fget( self ): + return self._rotationalstiffnessx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrotationalstiffnessselect): + self._rotationalstiffnessx = ifcrotationalstiffnessselect(value) + else: + self._rotationalstiffnessx = value + else: + self._rotationalstiffnessx = value + return property(**locals()) + + @apply + def rotationalstiffnessy(): + def fget( self ): + return self._rotationalstiffnessy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrotationalstiffnessselect): + self._rotationalstiffnessy = ifcrotationalstiffnessselect(value) + else: + self._rotationalstiffnessy = value + else: + self._rotationalstiffnessy = value + return property(**locals()) + + @apply + def rotationalstiffnessz(): + def fget( self ): + return self._rotationalstiffnessz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrotationalstiffnessselect): + self._rotationalstiffnessz = ifcrotationalstiffnessselect(value) + else: + self._rotationalstiffnessz = value + else: + self._rotationalstiffnessz = value + return property(**locals()) + +#################### + # ENTITY ifcboundarynodeconditionwarping # +#################### +class ifcboundarynodeconditionwarping(ifcboundarynodecondition): + '''Entity ifcboundarynodeconditionwarping definition. + + :param warpingstiffness + :type warpingstiffness:ifcwarpingstiffnessselect + ''' + def __init__( self , inherited0__name , inherited1__translationalstiffnessx , inherited2__translationalstiffnessy , inherited3__translationalstiffnessz , inherited4__rotationalstiffnessx , inherited5__rotationalstiffnessy , inherited6__rotationalstiffnessz , warpingstiffness, ): + ifcboundarynodecondition.__init__(self , inherited0__name , inherited1__translationalstiffnessx , inherited2__translationalstiffnessy , inherited3__translationalstiffnessz , inherited4__rotationalstiffnessx , inherited5__rotationalstiffnessy , inherited6__rotationalstiffnessz , ) + self.warpingstiffness = warpingstiffness + + @apply + def warpingstiffness(): + def fget( self ): + return self._warpingstiffness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcwarpingstiffnessselect): + self._warpingstiffness = ifcwarpingstiffnessselect(value) + else: + self._warpingstiffness = value + else: + self._warpingstiffness = value + return property(**locals()) + +#################### + # ENTITY ifclaborresourcetype # +#################### +class ifclaborresourcetype(ifcconstructionresourcetype): + '''Entity ifclaborresourcetype definition. + + :param predefinedtype + :type predefinedtype:ifclaborresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , predefinedtype, ): + ifcconstructionresourcetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifclaborresourcetypeenum): + self._predefinedtype = ifclaborresourcetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifclaborresourcetypeenum.self.userdefined) or ((self.predefinedtype == ifclaborresourcetypeenum.self.userdefined) and EXISTS(self.self.ifctyperesource.self.resourcetype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifctopologicalrepresentationitem # +#################### +class ifctopologicalrepresentationitem(ifcrepresentationitem): + '''Entity ifctopologicalrepresentationitem definition. + ''' + def __init__( self , ): + ifcrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifcedge # +#################### +class ifcedge(ifctopologicalrepresentationitem): + '''Entity ifcedge definition. + + :param edgestart + :type edgestart:ifcvertex + + :param edgeend + :type edgeend:ifcvertex + ''' + def __init__( self , edgestart,edgeend, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.edgestart = edgestart + self.edgeend = edgeend + + @apply + def edgestart(): + def fget( self ): + return self._edgestart + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgestart is mantatory and can not be set to None') + if not check_type(value,ifcvertex): + self._edgestart = ifcvertex(value) + else: + self._edgestart = value + return property(**locals()) + + @apply + def edgeend(): + def fget( self ): + return self._edgeend + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgeend is mantatory and can not be set to None') + if not check_type(value,ifcvertex): + self._edgeend = ifcvertex(value) + else: + self._edgeend = value + return property(**locals()) + +#################### + # ENTITY ifcsubedge # +#################### +class ifcsubedge(ifcedge): + '''Entity ifcsubedge definition. + + :param parentedge + :type parentedge:ifcedge + ''' + def __init__( self , inherited0__edgestart , inherited1__edgeend , parentedge, ): + ifcedge.__init__(self , inherited0__edgestart , inherited1__edgeend , ) + self.parentedge = parentedge + + @apply + def parentedge(): + def fget( self ): + return self._parentedge + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parentedge is mantatory and can not be set to None') + if not check_type(value,ifcedge): + self._parentedge = ifcedge(value) + else: + self._parentedge = value + return property(**locals()) + +#################### + # ENTITY ifcairtoairheatrecoverytype # +#################### +class ifcairtoairheatrecoverytype(ifcenergyconversiondevicetype): + '''Entity ifcairtoairheatrecoverytype definition. + + :param predefinedtype + :type predefinedtype:ifcairtoairheatrecoverytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcairtoairheatrecoverytypeenum): + self._predefinedtype = ifcairtoairheatrecoverytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcairtoairheatrecoverytypeenum.self.userdefined) or ((self.predefinedtype == ifcairtoairheatrecoverytypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccartesiantransformationoperator # +#################### +class ifccartesiantransformationoperator(ifcgeometricrepresentationitem): + '''Entity ifccartesiantransformationoperator definition. + + :param axis1 + :type axis1:ifcdirection + + :param axis2 + :type axis2:ifcdirection + + :param localorigin + :type localorigin:ifccartesianpoint + + :param scale + :type scale:REAL + + :param scl + :type scl:REAL + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , axis1,axis2,localorigin,scale, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.axis1 = axis1 + self.axis2 = axis2 + self.localorigin = localorigin + self.scale = scale + + @apply + def axis1(): + def fget( self ): + return self._axis1 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis1 = ifcdirection(value) + else: + self._axis1 = value + else: + self._axis1 = value + return property(**locals()) + + @apply + def axis2(): + def fget( self ): + return self._axis2 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis2 = ifcdirection(value) + else: + self._axis2 = value + else: + self._axis2 = value + return property(**locals()) + + @apply + def localorigin(): + def fget( self ): + return self._localorigin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument localorigin is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._localorigin = ifccartesianpoint(value) + else: + self._localorigin = value + return property(**locals()) + + @apply + def scale(): + def fget( self ): + return self._scale + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._scale = REAL(value) + else: + self._scale = value + else: + self._scale = value + return property(**locals()) + + @apply + def scl(): + def fget( self ): + attribute_eval = NVL(self.scale,1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scl is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.localorigin.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def scalegreaterzero(self): + eval_scalegreaterzero_wr = (self.scl > 0) + if not eval_scalegreaterzero_wr: + raise AssertionError('Rule scalegreaterzero violated') + else: + return eval_scalegreaterzero_wr + + +#################### + # ENTITY ifccartesiantransformationoperator3d # +#################### +class ifccartesiantransformationoperator3d(ifccartesiantransformationoperator): + '''Entity ifccartesiantransformationoperator3d definition. + + :param axis3 + :type axis3:ifcdirection + + :param u + :type u:LIST(3,3,'ifcdirection', scope = schema_scope) + ''' + def __init__( self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , axis3, ): + ifccartesiantransformationoperator.__init__(self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , ) + self.axis3 = axis3 + + @apply + def axis3(): + def fget( self ): + return self._axis3 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis3 = ifcdirection(value) + else: + self._axis3 = value + else: + self._axis3 = value + return property(**locals()) + + @apply + def u(): + def fget( self ): + attribute_eval = ifcbaseaxis(3,self.self.ifccartesiantransformationoperator.self.axis1,self.self.ifccartesiantransformationoperator.self.axis2,self.axis3) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument u is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def dimis3d(self): + eval_dimis3d_wr = (self.self.ifccartesiantransformationoperator.self.dim == 3) + if not eval_dimis3d_wr: + raise AssertionError('Rule dimis3d violated') + else: + return eval_dimis3d_wr + + def axis1is3d(self): + eval_axis1is3d_wr = (( not EXISTS(self.self.ifccartesiantransformationoperator.self.axis1)) or (self.self.ifccartesiantransformationoperator.self.axis1.self.dim == 3)) + if not eval_axis1is3d_wr: + raise AssertionError('Rule axis1is3d violated') + else: + return eval_axis1is3d_wr + + def axis2is3d(self): + eval_axis2is3d_wr = (( not EXISTS(self.self.ifccartesiantransformationoperator.self.axis2)) or (self.self.ifccartesiantransformationoperator.self.axis2.self.dim == 3)) + if not eval_axis2is3d_wr: + raise AssertionError('Rule axis2is3d violated') + else: + return eval_axis2is3d_wr + + def axis3is3d(self): + eval_axis3is3d_wr = (( not EXISTS(self.axis3)) or (self.axis3.self.dim == 3)) + if not eval_axis3is3d_wr: + raise AssertionError('Rule axis3is3d violated') + else: + return eval_axis3is3d_wr + + +#################### + # ENTITY ifcconnectiongeometry # +#################### +class ifcconnectiongeometry(BaseEntityClass): + '''Entity ifcconnectiongeometry definition. + ''' + # This class does not define any attribute. + pass + +#################### + # ENTITY ifcplanarextent # +#################### +class ifcplanarextent(ifcgeometricrepresentationitem): + '''Entity ifcplanarextent definition. + + :param sizeinx + :type sizeinx:ifclengthmeasure + + :param sizeiny + :type sizeiny:ifclengthmeasure + ''' + def __init__( self , sizeinx,sizeiny, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.sizeinx = sizeinx + self.sizeiny = sizeiny + + @apply + def sizeinx(): + def fget( self ): + return self._sizeinx + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sizeinx is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._sizeinx = ifclengthmeasure(value) + else: + self._sizeinx = value + return property(**locals()) + + @apply + def sizeiny(): + def fget( self ): + return self._sizeiny + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sizeiny is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._sizeiny = ifclengthmeasure(value) + else: + self._sizeiny = value + return property(**locals()) + +#################### + # ENTITY ifcplanarbox # +#################### +class ifcplanarbox(ifcplanarextent): + '''Entity ifcplanarbox definition. + + :param placement + :type placement:ifcaxis2placement + ''' + def __init__( self , inherited0__sizeinx , inherited1__sizeiny , placement, ): + ifcplanarextent.__init__(self , inherited0__sizeinx , inherited1__sizeiny , ) + self.placement = placement + + @apply + def placement(): + def fget( self ): + return self._placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placement is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._placement = ifcaxis2placement(value) + else: + self._placement = value + return property(**locals()) + +#################### + # ENTITY ifcreinforcingelementtype # +#################### +class ifcreinforcingelementtype(ifcelementcomponenttype): + '''Entity ifcreinforcingelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementcomponenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifctendontype # +#################### +class ifctendontype(ifcreinforcingelementtype): + '''Entity ifctendontype definition. + + :param predefinedtype + :type predefinedtype:ifctendontypeenum + + :param nominaldiameter + :type nominaldiameter:ifcpositivelengthmeasure + + :param crosssectionarea + :type crosssectionarea:ifcareameasure + + :param sheethdiameter + :type sheethdiameter:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype,nominaldiameter,crosssectionarea,sheethdiameter, ): + ifcreinforcingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + self.nominaldiameter = nominaldiameter + self.crosssectionarea = crosssectionarea + self.sheethdiameter = sheethdiameter + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctendontypeenum): + self._predefinedtype = ifctendontypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def nominaldiameter(): + def fget( self ): + return self._nominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominaldiameter = ifcpositivelengthmeasure(value) + else: + self._nominaldiameter = value + else: + self._nominaldiameter = value + return property(**locals()) + + @apply + def crosssectionarea(): + def fget( self ): + return self._crosssectionarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._crosssectionarea = ifcareameasure(value) + else: + self._crosssectionarea = value + else: + self._crosssectionarea = value + return property(**locals()) + + @apply + def sheethdiameter(): + def fget( self ): + return self._sheethdiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._sheethdiameter = ifcpositivelengthmeasure(value) + else: + self._sheethdiameter = value + else: + self._sheethdiameter = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifctendontypeenum.self.userdefined) or ((self.predefinedtype == ifctendontypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcfooting # +#################### +class ifcfooting(ifcbuildingelement): + '''Entity ifcfooting definition. + + :param predefinedtype + :type predefinedtype:ifcfootingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfootingtypeenum): + self._predefinedtype = ifcfootingtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcfootingtypeenum.self.userdefined)) or ((self.predefinedtype == ifcfootingtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCFOOTINGTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcpredefinedcolour # +#################### +class ifcpredefinedcolour(ifcpredefineditem): + '''Entity ifcpredefinedcolour definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefineditem.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcrelaggregates # +#################### +class ifcrelaggregates(ifcreldecomposes): + '''Entity ifcrelaggregates definition. + + :param relatingobject + :type relatingobject:ifcobjectdefinition + + :param relatedobjects + :type relatedobjects:SET(1,None,'ifcobjectdefinition', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingobject,relatedobjects, ): + ifcreldecomposes.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingobject = relatingobject + self.relatedobjects = relatedobjects + + @apply + def relatingobject(): + def fget( self ): + return self._relatingobject + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingobject is mantatory and can not be set to None') + if not check_type(value,ifcobjectdefinition): + self._relatingobject = ifcobjectdefinition(value) + else: + self._relatingobject = value + return property(**locals()) + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcobjectdefinition', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifctextstyle # +#################### +class ifctextstyle(ifcpresentationstyle): + '''Entity ifctextstyle definition. + + :param textcharacterappearance + :type textcharacterappearance:ifctextstylefordefinedfont + + :param textstyle + :type textstyle:ifctextstyletextmodel + + :param textfontstyle + :type textfontstyle:ifctextfontselect + + :param modelordraughting + :type modelordraughting:BOOLEAN + ''' + def __init__( self , inherited0__name , textcharacterappearance,textstyle,textfontstyle,modelordraughting, ): + ifcpresentationstyle.__init__(self , inherited0__name , ) + self.textcharacterappearance = textcharacterappearance + self.textstyle = textstyle + self.textfontstyle = textfontstyle + self.modelordraughting = modelordraughting + + @apply + def textcharacterappearance(): + def fget( self ): + return self._textcharacterappearance + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctextstylefordefinedfont): + self._textcharacterappearance = ifctextstylefordefinedfont(value) + else: + self._textcharacterappearance = value + else: + self._textcharacterappearance = value + return property(**locals()) + + @apply + def textstyle(): + def fget( self ): + return self._textstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctextstyletextmodel): + self._textstyle = ifctextstyletextmodel(value) + else: + self._textstyle = value + else: + self._textstyle = value + return property(**locals()) + + @apply + def textfontstyle(): + def fget( self ): + return self._textfontstyle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument textfontstyle is mantatory and can not be set to None') + if not check_type(value,ifctextfontselect): + self._textfontstyle = ifctextfontselect(value) + else: + self._textfontstyle = value + return property(**locals()) + + @apply + def modelordraughting(): + def fget( self ): + return self._modelordraughting + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._modelordraughting = BOOLEAN(value) + else: + self._modelordraughting = value + else: + self._modelordraughting = value + return property(**locals()) + +#################### + # ENTITY ifcwall # +#################### +class ifcwall(ifcbuildingelement): + '''Entity ifcwall definition. + + :param predefinedtype + :type predefinedtype:ifcwalltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcwalltypeenum): + self._predefinedtype = ifcwalltypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcwalltypeenum.self.userdefined)) or ((self.predefinedtype == ifcwalltypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCWALLTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcdistributioncontrolelementtype # +#################### +class ifcdistributioncontrolelementtype(ifcdistributionelementtype): + '''Entity ifcdistributioncontrolelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcactuatortype # +#################### +class ifcactuatortype(ifcdistributioncontrolelementtype): + '''Entity ifcactuatortype definition. + + :param predefinedtype + :type predefinedtype:ifcactuatortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcactuatortypeenum): + self._predefinedtype = ifcactuatortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcactuatortypeenum.self.userdefined) or ((self.predefinedtype == ifcactuatortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcfailureconnectioncondition # +#################### +class ifcfailureconnectioncondition(ifcstructuralconnectioncondition): + '''Entity ifcfailureconnectioncondition definition. + + :param tensionfailurex + :type tensionfailurex:ifcforcemeasure + + :param tensionfailurey + :type tensionfailurey:ifcforcemeasure + + :param tensionfailurez + :type tensionfailurez:ifcforcemeasure + + :param compressionfailurex + :type compressionfailurex:ifcforcemeasure + + :param compressionfailurey + :type compressionfailurey:ifcforcemeasure + + :param compressionfailurez + :type compressionfailurez:ifcforcemeasure + ''' + def __init__( self , inherited0__name , tensionfailurex,tensionfailurey,tensionfailurez,compressionfailurex,compressionfailurey,compressionfailurez, ): + ifcstructuralconnectioncondition.__init__(self , inherited0__name , ) + self.tensionfailurex = tensionfailurex + self.tensionfailurey = tensionfailurey + self.tensionfailurez = tensionfailurez + self.compressionfailurex = compressionfailurex + self.compressionfailurey = compressionfailurey + self.compressionfailurez = compressionfailurez + + @apply + def tensionfailurex(): + def fget( self ): + return self._tensionfailurex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._tensionfailurex = ifcforcemeasure(value) + else: + self._tensionfailurex = value + else: + self._tensionfailurex = value + return property(**locals()) + + @apply + def tensionfailurey(): + def fget( self ): + return self._tensionfailurey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._tensionfailurey = ifcforcemeasure(value) + else: + self._tensionfailurey = value + else: + self._tensionfailurey = value + return property(**locals()) + + @apply + def tensionfailurez(): + def fget( self ): + return self._tensionfailurez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._tensionfailurez = ifcforcemeasure(value) + else: + self._tensionfailurez = value + else: + self._tensionfailurez = value + return property(**locals()) + + @apply + def compressionfailurex(): + def fget( self ): + return self._compressionfailurex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._compressionfailurex = ifcforcemeasure(value) + else: + self._compressionfailurex = value + else: + self._compressionfailurex = value + return property(**locals()) + + @apply + def compressionfailurey(): + def fget( self ): + return self._compressionfailurey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._compressionfailurey = ifcforcemeasure(value) + else: + self._compressionfailurey = value + else: + self._compressionfailurey = value + return property(**locals()) + + @apply + def compressionfailurez(): + def fget( self ): + return self._compressionfailurez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._compressionfailurez = ifcforcemeasure(value) + else: + self._compressionfailurez = value + else: + self._compressionfailurez = value + return property(**locals()) + +#################### + # ENTITY ifcflowsegment # +#################### +class ifcflowsegment(ifcdistributionflowelement): + '''Entity ifcflowsegment definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifccablecarriersegment # +#################### +class ifccablecarriersegment(ifcflowsegment): + '''Entity ifccablecarriersegment definition. + + :param predefinedtype + :type predefinedtype:ifccablecarriersegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowsegment.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccablecarriersegmenttypeenum): + self._predefinedtype = ifccablecarriersegmenttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccablecarriersegmenttypeenum.self.userdefined)) or ((self.predefinedtype == ifccablecarriersegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCABLECARRIERSEGMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcstructuralsurfaceconnection # +#################### +class ifcstructuralsurfaceconnection(ifcstructuralconnection): + '''Entity ifcstructuralsurfaceconnection definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ): + ifcstructuralconnection.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ) + +#################### + # ENTITY ifctexturevertexlist # +#################### +class ifctexturevertexlist(ifcpresentationitem): + '''Entity ifctexturevertexlist definition. + + :param texcoordslist + :type texcoordslist:LIST(1,None,LIST(2,2,'REAL', scope = schema_scope)) + ''' + def __init__( self , texcoordslist, ): + ifcpresentationitem.__init__(self , ) + self.texcoordslist = texcoordslist + + @apply + def texcoordslist(): + def fget( self ): + return self._texcoordslist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument texcoordslist is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,LIST(2,2,'REAL', scope = schema_scope))): + self._texcoordslist = LIST(value) + else: + self._texcoordslist = value + return property(**locals()) + +#################### + # ENTITY ifccomplexproperty # +#################### +class ifccomplexproperty(ifcproperty): + '''Entity ifccomplexproperty definition. + + :param usagename + :type usagename:ifcidentifier + + :param hasproperties + :type hasproperties:SET(1,None,'ifcproperty', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , usagename,hasproperties, ): + ifcproperty.__init__(self , inherited0__name , inherited1__description , ) + self.usagename = usagename + self.hasproperties = hasproperties + + @apply + def usagename(): + def fget( self ): + return self._usagename + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument usagename is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._usagename = ifcidentifier(value) + else: + self._usagename = value + return property(**locals()) + + @apply + def hasproperties(): + def fget( self ): + return self._hasproperties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hasproperties is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproperty', scope = schema_scope)): + self._hasproperties = SET(value) + else: + self._hasproperties = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = ifcuniquepropertyname(self.hasproperties) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcflowcontroller # +#################### +class ifcflowcontroller(ifcdistributionflowelement): + '''Entity ifcflowcontroller definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcdamper # +#################### +class ifcdamper(ifcflowcontroller): + '''Entity ifcdamper definition. + + :param predefinedtype + :type predefinedtype:ifcdampertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowcontroller.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdampertypeenum): + self._predefinedtype = ifcdampertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcdampertypeenum.self.userdefined)) or ((self.predefinedtype == ifcdampertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCDAMPERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcboundedsurface # +#################### +class ifcboundedsurface(ifcsurface): + '''Entity ifcboundedsurface definition. + ''' + def __init__( self , ): + ifcsurface.__init__(self , ) + +#################### + # ENTITY ifccurveboundedplane # +#################### +class ifccurveboundedplane(ifcboundedsurface): + '''Entity ifccurveboundedplane definition. + + :param basissurface + :type basissurface:ifcplane + + :param outerboundary + :type outerboundary:ifccurve + + :param innerboundaries + :type innerboundaries:SET(0,None,'ifccurve', scope = schema_scope) + ''' + def __init__( self , basissurface,outerboundary,innerboundaries, ): + ifcboundedsurface.__init__(self , ) + self.basissurface = basissurface + self.outerboundary = outerboundary + self.innerboundaries = innerboundaries + + @apply + def basissurface(): + def fget( self ): + return self._basissurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basissurface is mantatory and can not be set to None') + if not check_type(value,ifcplane): + self._basissurface = ifcplane(value) + else: + self._basissurface = value + return property(**locals()) + + @apply + def outerboundary(): + def fget( self ): + return self._outerboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument outerboundary is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._outerboundary = ifccurve(value) + else: + self._outerboundary = value + return property(**locals()) + + @apply + def innerboundaries(): + def fget( self ): + return self._innerboundaries + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument innerboundaries is mantatory and can not be set to None') + if not check_type(value,SET(0,None,'ifccurve', scope = schema_scope)): + self._innerboundaries = SET(value) + else: + self._innerboundaries = value + return property(**locals()) + +#################### + # ENTITY ifcface # +#################### +class ifcface(ifctopologicalrepresentationitem): + '''Entity ifcface definition. + + :param bounds + :type bounds:SET(1,None,'ifcfacebound', scope = schema_scope) + + :param hastexturemaps + :type hastexturemaps:SET(0,None,'ifctexturemap', scope = schema_scope) + ''' + def __init__( self , bounds, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.bounds = bounds + + @apply + def bounds(): + def fget( self ): + return self._bounds + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bounds is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcfacebound', scope = schema_scope)): + self._bounds = SET(value) + else: + self._bounds = value + return property(**locals()) + + @apply + def hastexturemaps(): + def fget( self ): + return self._hastexturemaps + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hastexturemaps is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def hasouterbound(self): + eval_hasouterbound_wr = (SIZEOF(None) <= 1) + if not eval_hasouterbound_wr: + raise AssertionError('Rule hasouterbound violated') + else: + return eval_hasouterbound_wr + + +#################### + # ENTITY ifcfacesurface # +#################### +class ifcfacesurface(ifcface): + '''Entity ifcfacesurface definition. + + :param facesurface + :type facesurface:ifcsurface + + :param samesense + :type samesense:BOOLEAN + ''' + def __init__( self , inherited0__bounds , facesurface,samesense, ): + ifcface.__init__(self , inherited0__bounds , ) + self.facesurface = facesurface + self.samesense = samesense + + @apply + def facesurface(): + def fget( self ): + return self._facesurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument facesurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._facesurface = ifcsurface(value) + else: + self._facesurface = value + return property(**locals()) + + @apply + def samesense(): + def fget( self ): + return self._samesense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument samesense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._samesense = BOOLEAN(value) + else: + self._samesense = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralanalysismodel # +#################### +class ifcstructuralanalysismodel(ifcsystem): + '''Entity ifcstructuralanalysismodel definition. + + :param predefinedtype + :type predefinedtype:ifcanalysismodeltypeenum + + :param orientationof2dplane + :type orientationof2dplane:ifcaxis2placement3d + + :param loadedby + :type loadedby:SET(1,None,'ifcstructuralloadgroup', scope = schema_scope) + + :param hasresults + :type hasresults:SET(1,None,'ifcstructuralresultgroup', scope = schema_scope) + + :param sharedplacement + :type sharedplacement:ifcobjectplacement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , predefinedtype,orientationof2dplane,loadedby,hasresults,sharedplacement, ): + ifcsystem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.predefinedtype = predefinedtype + self.orientationof2dplane = orientationof2dplane + self.loadedby = loadedby + self.hasresults = hasresults + self.sharedplacement = sharedplacement + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcanalysismodeltypeenum): + self._predefinedtype = ifcanalysismodeltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def orientationof2dplane(): + def fget( self ): + return self._orientationof2dplane + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaxis2placement3d): + self._orientationof2dplane = ifcaxis2placement3d(value) + else: + self._orientationof2dplane = value + else: + self._orientationof2dplane = value + return property(**locals()) + + @apply + def loadedby(): + def fget( self ): + return self._loadedby + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcstructuralloadgroup', scope = schema_scope)): + self._loadedby = SET(value) + else: + self._loadedby = value + else: + self._loadedby = value + return property(**locals()) + + @apply + def hasresults(): + def fget( self ): + return self._hasresults + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcstructuralresultgroup', scope = schema_scope)): + self._hasresults = SET(value) + else: + self._hasresults = value + else: + self._hasresults = value + return property(**locals()) + + @apply + def sharedplacement(): + def fget( self ): + return self._sharedplacement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcobjectplacement): + self._sharedplacement = ifcobjectplacement(value) + else: + self._sharedplacement = value + else: + self._sharedplacement = value + return property(**locals()) + def hasobjecttype(self): + eval_hasobjecttype_wr = ((self.predefinedtype != ifcanalysismodeltypeenum.self.userdefined) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + +#################### + # ENTITY ifcstructuralloadsingleforce # +#################### +class ifcstructuralloadsingleforce(ifcstructuralloadstatic): + '''Entity ifcstructuralloadsingleforce definition. + + :param forcex + :type forcex:ifcforcemeasure + + :param forcey + :type forcey:ifcforcemeasure + + :param forcez + :type forcez:ifcforcemeasure + + :param momentx + :type momentx:ifctorquemeasure + + :param momenty + :type momenty:ifctorquemeasure + + :param momentz + :type momentz:ifctorquemeasure + ''' + def __init__( self , inherited0__name , forcex,forcey,forcez,momentx,momenty,momentz, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.forcex = forcex + self.forcey = forcey + self.forcez = forcez + self.momentx = momentx + self.momenty = momenty + self.momentz = momentz + + @apply + def forcex(): + def fget( self ): + return self._forcex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._forcex = ifcforcemeasure(value) + else: + self._forcex = value + else: + self._forcex = value + return property(**locals()) + + @apply + def forcey(): + def fget( self ): + return self._forcey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._forcey = ifcforcemeasure(value) + else: + self._forcey = value + else: + self._forcey = value + return property(**locals()) + + @apply + def forcez(): + def fget( self ): + return self._forcez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._forcez = ifcforcemeasure(value) + else: + self._forcez = value + else: + self._forcez = value + return property(**locals()) + + @apply + def momentx(): + def fget( self ): + return self._momentx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctorquemeasure): + self._momentx = ifctorquemeasure(value) + else: + self._momentx = value + else: + self._momentx = value + return property(**locals()) + + @apply + def momenty(): + def fget( self ): + return self._momenty + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctorquemeasure): + self._momenty = ifctorquemeasure(value) + else: + self._momenty = value + else: + self._momenty = value + return property(**locals()) + + @apply + def momentz(): + def fget( self ): + return self._momentz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctorquemeasure): + self._momentz = ifctorquemeasure(value) + else: + self._momentz = value + else: + self._momentz = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralloadsingleforcewarping # +#################### +class ifcstructuralloadsingleforcewarping(ifcstructuralloadsingleforce): + '''Entity ifcstructuralloadsingleforcewarping definition. + + :param warpingmoment + :type warpingmoment:ifcwarpingmomentmeasure + ''' + def __init__( self , inherited0__name , inherited1__forcex , inherited2__forcey , inherited3__forcez , inherited4__momentx , inherited5__momenty , inherited6__momentz , warpingmoment, ): + ifcstructuralloadsingleforce.__init__(self , inherited0__name , inherited1__forcex , inherited2__forcey , inherited3__forcez , inherited4__momentx , inherited5__momenty , inherited6__momentz , ) + self.warpingmoment = warpingmoment + + @apply + def warpingmoment(): + def fget( self ): + return self._warpingmoment + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcwarpingmomentmeasure): + self._warpingmoment = ifcwarpingmomentmeasure(value) + else: + self._warpingmoment = value + else: + self._warpingmoment = value + return property(**locals()) + +#################### + # ENTITY ifcaudiovisualappliancetype # +#################### +class ifcaudiovisualappliancetype(ifcflowterminaltype): + '''Entity ifcaudiovisualappliancetype definition. + + :param predefinedtype + :type predefinedtype:ifcaudiovisualappliancetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcaudiovisualappliancetypeenum): + self._predefinedtype = ifcaudiovisualappliancetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcaudiovisualappliancetypeenum.self.userdefined) or ((self.predefinedtype == ifcaudiovisualappliancetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcaxis2placement3d # +#################### +class ifcaxis2placement3d(ifcplacement): + '''Entity ifcaxis2placement3d definition. + + :param axis + :type axis:ifcdirection + + :param refdirection + :type refdirection:ifcdirection + + :param p + :type p:LIST(3,3,'ifcdirection', scope = schema_scope) + ''' + def __init__( self , inherited0__location , axis,refdirection, ): + ifcplacement.__init__(self , inherited0__location , ) + self.axis = axis + self.refdirection = refdirection + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._axis = ifcdirection(value) + else: + self._axis = value + else: + self._axis = value + return property(**locals()) + + @apply + def refdirection(): + def fget( self ): + return self._refdirection + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._refdirection = ifcdirection(value) + else: + self._refdirection = value + else: + self._refdirection = value + return property(**locals()) + + @apply + def p(): + def fget( self ): + attribute_eval = ifcbuildaxes(self.axis,self.refdirection) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument p is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def locationis3d(self): + eval_locationis3d_wr = (self.self.ifcplacement.self.location.self.dim == 3) + if not eval_locationis3d_wr: + raise AssertionError('Rule locationis3d violated') + else: + return eval_locationis3d_wr + + def axisis3d(self): + eval_axisis3d_wr = (( not EXISTS(self.axis)) or (self.axis.self.dim == 3)) + if not eval_axisis3d_wr: + raise AssertionError('Rule axisis3d violated') + else: + return eval_axisis3d_wr + + def refdiris3d(self): + eval_refdiris3d_wr = (( not EXISTS(self.refdirection)) or (self.refdirection.self.dim == 3)) + if not eval_refdiris3d_wr: + raise AssertionError('Rule refdiris3d violated') + else: + return eval_refdiris3d_wr + + def axistorefdirposition(self): + eval_axistorefdirposition_wr = ((( not EXISTS(self.axis)) or ( not EXISTS(self.refdirection))) or (ifccrossproduct(self.axis,self.refdirection).self.magnitude > 0)) + if not eval_axistorefdirposition_wr: + raise AssertionError('Rule axistorefdirposition violated') + else: + return eval_axistorefdirposition_wr + + def axisandrefdirprovision(self): + eval_axisandrefdirprovision_wr = ( not (EXISTS(self.axis) XOR EXISTS(self.refdirection))) + if not eval_axisandrefdirprovision_wr: + raise AssertionError('Rule axisandrefdirprovision violated') + else: + return eval_axisandrefdirprovision_wr + + +#################### + # ENTITY ifcmaterialusagedefinition # +#################### +class ifcmaterialusagedefinition(BaseEntityClass): + '''Entity ifcmaterialusagedefinition definition. + + :param associatedto + :type associatedto:SET(1,None,'ifcrelassociatesmaterial', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def associatedto(): + def fget( self ): + return self._associatedto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument associatedto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcmaterialprofilesetusage # +#################### +class ifcmaterialprofilesetusage(ifcmaterialusagedefinition): + '''Entity ifcmaterialprofilesetusage definition. + + :param forprofileset + :type forprofileset:ifcmaterialprofileset + + :param cardinalpoint + :type cardinalpoint:ifccardinalpointreference + + :param referenceextent + :type referenceextent:ifcpositivelengthmeasure + ''' + def __init__( self , forprofileset,cardinalpoint,referenceextent, ): + ifcmaterialusagedefinition.__init__(self , ) + self.forprofileset = forprofileset + self.cardinalpoint = cardinalpoint + self.referenceextent = referenceextent + + @apply + def forprofileset(): + def fget( self ): + return self._forprofileset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument forprofileset is mantatory and can not be set to None') + if not check_type(value,ifcmaterialprofileset): + self._forprofileset = ifcmaterialprofileset(value) + else: + self._forprofileset = value + return property(**locals()) + + @apply + def cardinalpoint(): + def fget( self ): + return self._cardinalpoint + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccardinalpointreference): + self._cardinalpoint = ifccardinalpointreference(value) + else: + self._cardinalpoint = value + else: + self._cardinalpoint = value + return property(**locals()) + + @apply + def referenceextent(): + def fget( self ): + return self._referenceextent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._referenceextent = ifcpositivelengthmeasure(value) + else: + self._referenceextent = value + else: + self._referenceextent = value + return property(**locals()) + +#################### + # ENTITY ifcmaterialprofilesetusagetapering # +#################### +class ifcmaterialprofilesetusagetapering(ifcmaterialprofilesetusage): + '''Entity ifcmaterialprofilesetusagetapering definition. + + :param forprofileendset + :type forprofileendset:ifcmaterialprofileset + + :param cardinalendpoint + :type cardinalendpoint:ifccardinalpointreference + ''' + def __init__( self , inherited0__forprofileset , inherited1__cardinalpoint , inherited2__referenceextent , forprofileendset,cardinalendpoint, ): + ifcmaterialprofilesetusage.__init__(self , inherited0__forprofileset , inherited1__cardinalpoint , inherited2__referenceextent , ) + self.forprofileendset = forprofileendset + self.cardinalendpoint = cardinalendpoint + + @apply + def forprofileendset(): + def fget( self ): + return self._forprofileendset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument forprofileendset is mantatory and can not be set to None') + if not check_type(value,ifcmaterialprofileset): + self._forprofileendset = ifcmaterialprofileset(value) + else: + self._forprofileendset = value + return property(**locals()) + + @apply + def cardinalendpoint(): + def fget( self ): + return self._cardinalendpoint + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccardinalpointreference): + self._cardinalendpoint = ifccardinalpointreference(value) + else: + self._cardinalendpoint = value + else: + self._cardinalendpoint = value + return property(**locals()) + +#################### + # ENTITY ifchalfspacesolid # +#################### +class ifchalfspacesolid(ifcgeometricrepresentationitem): + '''Entity ifchalfspacesolid definition. + + :param basesurface + :type basesurface:ifcsurface + + :param agreementflag + :type agreementflag:BOOLEAN + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , basesurface,agreementflag, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.basesurface = basesurface + self.agreementflag = agreementflag + + @apply + def basesurface(): + def fget( self ): + return self._basesurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basesurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._basesurface = ifcsurface(value) + else: + self._basesurface = value + return property(**locals()) + + @apply + def agreementflag(): + def fget( self ): + return self._agreementflag + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument agreementflag is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._agreementflag = BOOLEAN(value) + else: + self._agreementflag = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcboxedhalfspace # +#################### +class ifcboxedhalfspace(ifchalfspacesolid): + '''Entity ifcboxedhalfspace definition. + + :param enclosure + :type enclosure:ifcboundingbox + ''' + def __init__( self , inherited0__basesurface , inherited1__agreementflag , enclosure, ): + ifchalfspacesolid.__init__(self , inherited0__basesurface , inherited1__agreementflag , ) + self.enclosure = enclosure + + @apply + def enclosure(): + def fget( self ): + return self._enclosure + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument enclosure is mantatory and can not be set to None') + if not check_type(value,ifcboundingbox): + self._enclosure = ifcboundingbox(value) + else: + self._enclosure = value + return property(**locals()) + +#################### + # ENTITY ifccompositecurve # +#################### +class ifccompositecurve(ifcboundedcurve): + '''Entity ifccompositecurve definition. + + :param segments + :type segments:LIST(1,None,'ifccompositecurvesegment', scope = schema_scope) + + :param selfintersect + :type selfintersect:LOGICAL + + :param nsegments + :type nsegments:INTEGER + + :param closedcurve + :type closedcurve:LOGICAL + ''' + def __init__( self , segments,selfintersect, ): + ifcboundedcurve.__init__(self , ) + self.segments = segments + self.selfintersect = selfintersect + + @apply + def segments(): + def fget( self ): + return self._segments + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument segments is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifccompositecurvesegment', scope = schema_scope)): + self._segments = LIST(value) + else: + self._segments = value + return property(**locals()) + + @apply + def selfintersect(): + def fget( self ): + return self._selfintersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument selfintersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._selfintersect = LOGICAL(value) + else: + self._selfintersect = value + return property(**locals()) + + @apply + def nsegments(): + def fget( self ): + attribute_eval = SIZEOF(self.segments) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument nsegments is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def closedcurve(): + def fget( self ): + attribute_eval = (self.segments[self.nsegments].self.transition != discontinuous) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument closedcurve is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def curvecontinuous(self): + eval_curvecontinuous_wr = ((( not self.closedcurve) and (SIZEOF(None) == 1)) or (self.closedcurve and (SIZEOF(None) == 0))) + if not eval_curvecontinuous_wr: + raise AssertionError('Rule curvecontinuous violated') + else: + return eval_curvecontinuous_wr + + def samedim(self): + eval_samedim_wr = (SIZEOF(None) == 0) + if not eval_samedim_wr: + raise AssertionError('Rule samedim violated') + else: + return eval_samedim_wr + + +#################### + # ENTITY ifcdoortype # +#################### +class ifcdoortype(ifcbuildingelementtype): + '''Entity ifcdoortype definition. + + :param predefinedtype + :type predefinedtype:ifcdoortypeenum + + :param operationtype + :type operationtype:ifcdoortypeoperationenum + + :param parametertakesprecedence + :type parametertakesprecedence:BOOLEAN + + :param userdefinedoperationtype + :type userdefinedoperationtype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype,operationtype,parametertakesprecedence,userdefinedoperationtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + self.operationtype = operationtype + self.parametertakesprecedence = parametertakesprecedence + self.userdefinedoperationtype = userdefinedoperationtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcdoortypeenum): + self._predefinedtype = ifcdoortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operationtype is mantatory and can not be set to None') + if not check_type(value,ifcdoortypeoperationenum): + self._operationtype = ifcdoortypeoperationenum(value) + else: + self._operationtype = value + return property(**locals()) + + @apply + def parametertakesprecedence(): + def fget( self ): + return self._parametertakesprecedence + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._parametertakesprecedence = BOOLEAN(value) + else: + self._parametertakesprecedence = value + else: + self._parametertakesprecedence = value + return property(**locals()) + + @apply + def userdefinedoperationtype(): + def fget( self ): + return self._userdefinedoperationtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedoperationtype = ifclabel(value) + else: + self._userdefinedoperationtype = value + else: + self._userdefinedoperationtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcdoortypeenum.self.userdefined) or ((self.predefinedtype == ifcdoortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcroof # +#################### +class ifcroof(ifcbuildingelement): + '''Entity ifcroof definition. + + :param predefinedtype + :type predefinedtype:ifcrooftypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrooftypeenum): + self._predefinedtype = ifcrooftypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctshapedecomposition(self): + eval_correctshapedecomposition_wr = ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 0) or ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 1) and (( not EXISTS(self.self.ifcproduct.self.representation)) or (EXISTS(self.self.ifcproduct.self.representation) and (SIZEOF(None) == 0))))) + if not eval_correctshapedecomposition_wr: + raise AssertionError('Rule correctshapedecomposition violated') + else: + return eval_correctshapedecomposition_wr + + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcrooftypeenum.self.userdefined)) or ((self.predefinedtype == ifcrooftypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCROOFTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcstructuralloadsingledisplacementdistortion # +#################### +class ifcstructuralloadsingledisplacementdistortion(ifcstructuralloadsingledisplacement): + '''Entity ifcstructuralloadsingledisplacementdistortion definition. + + :param distortion + :type distortion:ifccurvaturemeasure + ''' + def __init__( self , inherited0__name , inherited1__displacementx , inherited2__displacementy , inherited3__displacementz , inherited4__rotationaldisplacementrx , inherited5__rotationaldisplacementry , inherited6__rotationaldisplacementrz , distortion, ): + ifcstructuralloadsingledisplacement.__init__(self , inherited0__name , inherited1__displacementx , inherited2__displacementy , inherited3__displacementz , inherited4__rotationaldisplacementrx , inherited5__rotationaldisplacementry , inherited6__rotationaldisplacementrz , ) + self.distortion = distortion + + @apply + def distortion(): + def fget( self ): + return self._distortion + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccurvaturemeasure): + self._distortion = ifccurvaturemeasure(value) + else: + self._distortion = value + else: + self._distortion = value + return property(**locals()) + +#################### + # ENTITY ifcburner # +#################### +class ifcburner(ifcenergyconversiondevice): + '''Entity ifcburner definition. + + :param predefinedtype + :type predefinedtype:ifcburnertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcburnertypeenum): + self._predefinedtype = ifcburnertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcburnertypeenum.self.userdefined)) or ((self.predefinedtype == ifcburnertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCBURNERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifceventtype # +#################### +class ifceventtype(ifctypeprocess): + '''Entity ifceventtype definition. + + :param predefinedtype + :type predefinedtype:ifceventtypeenum + + :param eventtriggertype + :type eventtriggertype:ifceventtriggertypeenum + + :param userdefinedeventtriggertype + :type userdefinedeventtriggertype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__processtype , predefinedtype,eventtriggertype,userdefinedeventtriggertype, ): + ifctypeprocess.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__processtype , ) + self.predefinedtype = predefinedtype + self.eventtriggertype = eventtriggertype + self.userdefinedeventtriggertype = userdefinedeventtriggertype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifceventtypeenum): + self._predefinedtype = ifceventtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def eventtriggertype(): + def fget( self ): + return self._eventtriggertype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument eventtriggertype is mantatory and can not be set to None') + if not check_type(value,ifceventtriggertypeenum): + self._eventtriggertype = ifceventtriggertypeenum(value) + else: + self._eventtriggertype = value + return property(**locals()) + + @apply + def userdefinedeventtriggertype(): + def fget( self ): + return self._userdefinedeventtriggertype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedeventtriggertype = ifclabel(value) + else: + self._userdefinedeventtriggertype = value + else: + self._userdefinedeventtriggertype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifceventtypeenum.self.userdefined) or ((self.predefinedtype == ifceventtypeenum.self.userdefined) and EXISTS(self.self.ifctypeprocess.self.processtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcteventtriggertype(self): + eval_correcteventtriggertype_wr = ((self.eventtriggertype != ifceventtriggertypeenum.self.userdefined) or ((self.eventtriggertype == ifceventtriggertypeenum.self.userdefined) and EXISTS(self.userdefinedeventtriggertype))) + if not eval_correcteventtriggertype_wr: + raise AssertionError('Rule correcteventtriggertype violated') + else: + return eval_correcteventtriggertype_wr + + +#################### + # ENTITY ifcmaterialprofile # +#################### +class ifcmaterialprofile(ifcmaterialdefinition): + '''Entity ifcmaterialprofile definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param material + :type material:ifcmaterial + + :param profile + :type profile:ifcprofiledef + + :param priority + :type priority:ifcnormalisedratiomeasure + + :param category + :type category:ifclabel + + :param tomaterialprofileset + :type tomaterialprofileset:ifcmaterialprofileset + ''' + def __init__( self , name,description,material,profile,priority,category, ): + ifcmaterialdefinition.__init__(self , ) + self.name = name + self.description = description + self.material = material + self.profile = profile + self.priority = priority + self.category = category + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def material(): + def fget( self ): + return self._material + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmaterial): + self._material = ifcmaterial(value) + else: + self._material = value + else: + self._material = value + return property(**locals()) + + @apply + def profile(): + def fget( self ): + return self._profile + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument profile is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._profile = ifcprofiledef(value) + else: + self._profile = value + return property(**locals()) + + @apply + def priority(): + def fget( self ): + return self._priority + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._priority = ifcnormalisedratiomeasure(value) + else: + self._priority = value + else: + self._priority = value + return property(**locals()) + + @apply + def category(): + def fget( self ): + return self._category + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._category = ifclabel(value) + else: + self._category = value + else: + self._category = value + return property(**locals()) + + @apply + def tomaterialprofileset(): + def fget( self ): + return self._tomaterialprofileset + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument tomaterialprofileset is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcmaterialprofilewithoffsets # +#################### +class ifcmaterialprofilewithoffsets(ifcmaterialprofile): + '''Entity ifcmaterialprofilewithoffsets definition. + + :param offsetvalues + :type offsetvalues:ARRAY(1,2,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__material , inherited3__profile , inherited4__priority , inherited5__category , offsetvalues, ): + ifcmaterialprofile.__init__(self , inherited0__name , inherited1__description , inherited2__material , inherited3__profile , inherited4__priority , inherited5__category , ) + self.offsetvalues = offsetvalues + + @apply + def offsetvalues(): + def fget( self ): + return self._offsetvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument offsetvalues is mantatory and can not be set to None') + if not check_type(value,ARRAY(1,2,'REAL', scope = schema_scope)): + self._offsetvalues = ARRAY(value) + else: + self._offsetvalues = value + return property(**locals()) + +#################### + # ENTITY ifcrepresentation # +#################### +class ifcrepresentation(BaseEntityClass): + '''Entity ifcrepresentation definition. + + :param contextofitems + :type contextofitems:ifcrepresentationcontext + + :param representationidentifier + :type representationidentifier:ifclabel + + :param representationtype + :type representationtype:ifclabel + + :param items + :type items:SET(1,None,'ifcrepresentationitem', scope = schema_scope) + + :param representationmap + :type representationmap:SET(0,1,'ifcrepresentationmap', scope = schema_scope) + + :param layerassignments + :type layerassignments:SET(0,None,'ifcpresentationlayerassignment', scope = schema_scope) + + :param ofproductrepresentation + :type ofproductrepresentation:SET(0,None,'ifcproductrepresentation', scope = schema_scope) + ''' + def __init__( self , contextofitems,representationidentifier,representationtype,items, ): + self.contextofitems = contextofitems + self.representationidentifier = representationidentifier + self.representationtype = representationtype + self.items = items + + @apply + def contextofitems(): + def fget( self ): + return self._contextofitems + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument contextofitems is mantatory and can not be set to None') + if not check_type(value,ifcrepresentationcontext): + self._contextofitems = ifcrepresentationcontext(value) + else: + self._contextofitems = value + return property(**locals()) + + @apply + def representationidentifier(): + def fget( self ): + return self._representationidentifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._representationidentifier = ifclabel(value) + else: + self._representationidentifier = value + else: + self._representationidentifier = value + return property(**locals()) + + @apply + def representationtype(): + def fget( self ): + return self._representationtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._representationtype = ifclabel(value) + else: + self._representationtype = value + else: + self._representationtype = value + return property(**locals()) + + @apply + def items(): + def fget( self ): + return self._items + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument items is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcrepresentationitem', scope = schema_scope)): + self._items = SET(value) + else: + self._items = value + return property(**locals()) + + @apply + def representationmap(): + def fget( self ): + return self._representationmap + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument representationmap is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def layerassignments(): + def fget( self ): + return self._layerassignments + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument layerassignments is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ofproductrepresentation(): + def fget( self ): + return self._ofproductrepresentation + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ofproductrepresentation is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcfilter # +#################### +class ifcfilter(ifcflowtreatmentdevice): + '''Entity ifcfilter definition. + + :param predefinedtype + :type predefinedtype:ifcfiltertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowtreatmentdevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfiltertypeenum): + self._predefinedtype = ifcfiltertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcfiltertypeenum.self.userdefined)) or ((self.predefinedtype == ifcfiltertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCFILTERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcresourceapprovalrelationship # +#################### +class ifcresourceapprovalrelationship(ifcresourcelevelrelationship): + '''Entity ifcresourceapprovalrelationship definition. + + :param relatedresourceobjects + :type relatedresourceobjects:SET(1,None,'ifcresourceobjectselect', scope = schema_scope) + + :param relatingapproval + :type relatingapproval:ifcapproval + ''' + def __init__( self , inherited0__name , inherited1__description , relatedresourceobjects,relatingapproval, ): + ifcresourcelevelrelationship.__init__(self , inherited0__name , inherited1__description , ) + self.relatedresourceobjects = relatedresourceobjects + self.relatingapproval = relatingapproval + + @apply + def relatedresourceobjects(): + def fget( self ): + return self._relatedresourceobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedresourceobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcresourceobjectselect', scope = schema_scope)): + self._relatedresourceobjects = SET(value) + else: + self._relatedresourceobjects = value + return property(**locals()) + + @apply + def relatingapproval(): + def fget( self ): + return self._relatingapproval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingapproval is mantatory and can not be set to None') + if not check_type(value,ifcapproval): + self._relatingapproval = ifcapproval(value) + else: + self._relatingapproval = value + return property(**locals()) + +#################### + # ENTITY ifcjunctionbox # +#################### +class ifcjunctionbox(ifcflowfitting): + '''Entity ifcjunctionbox definition. + + :param predefinedtype + :type predefinedtype:ifcjunctionboxtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowfitting.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcjunctionboxtypeenum): + self._predefinedtype = ifcjunctionboxtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcjunctionboxtypeenum.self.userdefined)) or ((self.predefinedtype == ifcjunctionboxtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCJUNCTIONBOXTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcoffsetcurve2d # +#################### +class ifcoffsetcurve2d(ifccurve): + '''Entity ifcoffsetcurve2d definition. + + :param basiscurve + :type basiscurve:ifccurve + + :param distance + :type distance:ifclengthmeasure + + :param selfintersect + :type selfintersect:LOGICAL + ''' + def __init__( self , basiscurve,distance,selfintersect, ): + ifccurve.__init__(self , ) + self.basiscurve = basiscurve + self.distance = distance + self.selfintersect = selfintersect + + @apply + def basiscurve(): + def fget( self ): + return self._basiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._basiscurve = ifccurve(value) + else: + self._basiscurve = value + return property(**locals()) + + @apply + def distance(): + def fget( self ): + return self._distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distance is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._distance = ifclengthmeasure(value) + else: + self._distance = value + return property(**locals()) + + @apply + def selfintersect(): + def fget( self ): + return self._selfintersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument selfintersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._selfintersect = LOGICAL(value) + else: + self._selfintersect = value + return property(**locals()) + def dimis2d(self): + eval_dimis2d_wr = (self.basiscurve.self.dim == 2) + if not eval_dimis2d_wr: + raise AssertionError('Rule dimis2d violated') + else: + return eval_dimis2d_wr + + +#################### + # ENTITY ifcrelassigns # +#################### +class ifcrelassigns(ifcrelationship): + '''Entity ifcrelassigns definition. + + :param relatedobjects + :type relatedobjects:SET(1,None,'ifcobjectdefinition', scope = schema_scope) + + :param relatedobjectstype + :type relatedobjectstype:ifcobjecttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedobjects,relatedobjectstype, ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedobjects = relatedobjects + self.relatedobjectstype = relatedobjectstype + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcobjectdefinition', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + + @apply + def relatedobjectstype(): + def fget( self ): + return self._relatedobjectstype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcobjecttypeenum): + self._relatedobjectstype = ifcobjecttypeenum(value) + else: + self._relatedobjectstype = value + else: + self._relatedobjectstype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ifccorrectobjectassignment(self.relatedobjectstype,self.relatedobjects) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelassignstogroup # +#################### +class ifcrelassignstogroup(ifcrelassigns): + '''Entity ifcrelassignstogroup definition. + + :param relatinggroup + :type relatinggroup:ifcgroup + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatinggroup, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatinggroup = relatinggroup + + @apply + def relatinggroup(): + def fget( self ): + return self._relatinggroup + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatinggroup is mantatory and can not be set to None') + if not check_type(value,ifcgroup): + self._relatinggroup = ifcgroup(value) + else: + self._relatinggroup = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcreinforcementdefinitionproperties # +#################### +class ifcreinforcementdefinitionproperties(ifcpredefinedpropertyset): + '''Entity ifcreinforcementdefinitionproperties definition. + + :param definitiontype + :type definitiontype:ifclabel + + :param reinforcementsectiondefinitions + :type reinforcementsectiondefinitions:LIST(1,None,'ifcsectionreinforcementproperties', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , definitiontype,reinforcementsectiondefinitions, ): + ifcpredefinedpropertyset.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.definitiontype = definitiontype + self.reinforcementsectiondefinitions = reinforcementsectiondefinitions + + @apply + def definitiontype(): + def fget( self ): + return self._definitiontype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._definitiontype = ifclabel(value) + else: + self._definitiontype = value + else: + self._definitiontype = value + return property(**locals()) + + @apply + def reinforcementsectiondefinitions(): + def fget( self ): + return self._reinforcementsectiondefinitions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reinforcementsectiondefinitions is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcsectionreinforcementproperties', scope = schema_scope)): + self._reinforcementsectiondefinitions = LIST(value) + else: + self._reinforcementsectiondefinitions = value + return property(**locals()) + +#################### + # ENTITY ifcrelassociatesclassification # +#################### +class ifcrelassociatesclassification(ifcrelassociates): + '''Entity ifcrelassociatesclassification definition. + + :param relatingclassification + :type relatingclassification:ifcclassificationselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingclassification, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingclassification = relatingclassification + + @apply + def relatingclassification(): + def fget( self ): + return self._relatingclassification + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingclassification is mantatory and can not be set to None') + if not check_type(value,ifcclassificationselect): + self._relatingclassification = ifcclassificationselect(value) + else: + self._relatingclassification = value + return property(**locals()) + +#################### + # ENTITY ifcrelvoidselement # +#################### +class ifcrelvoidselement(ifcreldecomposes): + '''Entity ifcrelvoidselement definition. + + :param relatingbuildingelement + :type relatingbuildingelement:ifcelement + + :param relatedopeningelement + :type relatedopeningelement:ifcfeatureelementsubtraction + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingbuildingelement,relatedopeningelement, ): + ifcreldecomposes.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingbuildingelement = relatingbuildingelement + self.relatedopeningelement = relatedopeningelement + + @apply + def relatingbuildingelement(): + def fget( self ): + return self._relatingbuildingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingbuildingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingbuildingelement = ifcelement(value) + else: + self._relatingbuildingelement = value + return property(**locals()) + + @apply + def relatedopeningelement(): + def fget( self ): + return self._relatedopeningelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedopeningelement is mantatory and can not be set to None') + if not check_type(value,ifcfeatureelementsubtraction): + self._relatedopeningelement = ifcfeatureelementsubtraction(value) + else: + self._relatedopeningelement = value + return property(**locals()) + +#################### + # ENTITY ifcboundaryedgecondition # +#################### +class ifcboundaryedgecondition(ifcboundarycondition): + '''Entity ifcboundaryedgecondition definition. + + :param translationalstiffnessbylengthx + :type translationalstiffnessbylengthx:ifcmodulusoftranslationalsubgradereactionselect + + :param translationalstiffnessbylengthy + :type translationalstiffnessbylengthy:ifcmodulusoftranslationalsubgradereactionselect + + :param translationalstiffnessbylengthz + :type translationalstiffnessbylengthz:ifcmodulusoftranslationalsubgradereactionselect + + :param rotationalstiffnessbylengthx + :type rotationalstiffnessbylengthx:ifcmodulusofrotationalsubgradereactionselect + + :param rotationalstiffnessbylengthy + :type rotationalstiffnessbylengthy:ifcmodulusofrotationalsubgradereactionselect + + :param rotationalstiffnessbylengthz + :type rotationalstiffnessbylengthz:ifcmodulusofrotationalsubgradereactionselect + ''' + def __init__( self , inherited0__name , translationalstiffnessbylengthx,translationalstiffnessbylengthy,translationalstiffnessbylengthz,rotationalstiffnessbylengthx,rotationalstiffnessbylengthy,rotationalstiffnessbylengthz, ): + ifcboundarycondition.__init__(self , inherited0__name , ) + self.translationalstiffnessbylengthx = translationalstiffnessbylengthx + self.translationalstiffnessbylengthy = translationalstiffnessbylengthy + self.translationalstiffnessbylengthz = translationalstiffnessbylengthz + self.rotationalstiffnessbylengthx = rotationalstiffnessbylengthx + self.rotationalstiffnessbylengthy = rotationalstiffnessbylengthy + self.rotationalstiffnessbylengthz = rotationalstiffnessbylengthz + + @apply + def translationalstiffnessbylengthx(): + def fget( self ): + return self._translationalstiffnessbylengthx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusoftranslationalsubgradereactionselect): + self._translationalstiffnessbylengthx = ifcmodulusoftranslationalsubgradereactionselect(value) + else: + self._translationalstiffnessbylengthx = value + else: + self._translationalstiffnessbylengthx = value + return property(**locals()) + + @apply + def translationalstiffnessbylengthy(): + def fget( self ): + return self._translationalstiffnessbylengthy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusoftranslationalsubgradereactionselect): + self._translationalstiffnessbylengthy = ifcmodulusoftranslationalsubgradereactionselect(value) + else: + self._translationalstiffnessbylengthy = value + else: + self._translationalstiffnessbylengthy = value + return property(**locals()) + + @apply + def translationalstiffnessbylengthz(): + def fget( self ): + return self._translationalstiffnessbylengthz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusoftranslationalsubgradereactionselect): + self._translationalstiffnessbylengthz = ifcmodulusoftranslationalsubgradereactionselect(value) + else: + self._translationalstiffnessbylengthz = value + else: + self._translationalstiffnessbylengthz = value + return property(**locals()) + + @apply + def rotationalstiffnessbylengthx(): + def fget( self ): + return self._rotationalstiffnessbylengthx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofrotationalsubgradereactionselect): + self._rotationalstiffnessbylengthx = ifcmodulusofrotationalsubgradereactionselect(value) + else: + self._rotationalstiffnessbylengthx = value + else: + self._rotationalstiffnessbylengthx = value + return property(**locals()) + + @apply + def rotationalstiffnessbylengthy(): + def fget( self ): + return self._rotationalstiffnessbylengthy + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofrotationalsubgradereactionselect): + self._rotationalstiffnessbylengthy = ifcmodulusofrotationalsubgradereactionselect(value) + else: + self._rotationalstiffnessbylengthy = value + else: + self._rotationalstiffnessbylengthy = value + return property(**locals()) + + @apply + def rotationalstiffnessbylengthz(): + def fget( self ): + return self._rotationalstiffnessbylengthz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofrotationalsubgradereactionselect): + self._rotationalstiffnessbylengthz = ifcmodulusofrotationalsubgradereactionselect(value) + else: + self._rotationalstiffnessbylengthz = value + else: + self._rotationalstiffnessbylengthz = value + return property(**locals()) + +#################### + # ENTITY ifcenginetype # +#################### +class ifcenginetype(ifcenergyconversiondevicetype): + '''Entity ifcenginetype definition. + + :param predefinedtype + :type predefinedtype:ifcenginetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcenginetypeenum): + self._predefinedtype = ifcenginetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcenginetypeenum.self.userdefined) or ((self.predefinedtype == ifcenginetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcflowtreatmentdevicetype # +#################### +class ifcflowtreatmentdevicetype(ifcdistributionflowelementtype): + '''Entity ifcflowtreatmentdevicetype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcgeometricset # +#################### +class ifcgeometricset(ifcgeometricrepresentationitem): + '''Entity ifcgeometricset definition. + + :param elements + :type elements:SET(1,None,'ifcgeometricsetselect', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , elements, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.elements = elements + + @apply + def elements(): + def fget( self ): + return self._elements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument elements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcgeometricsetselect', scope = schema_scope)): + self._elements = SET(value) + else: + self._elements = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.elements[1].self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def consistentdim(self): + eval_consistentdim_wr = (SIZEOF(None) == 0) + if not eval_consistentdim_wr: + raise AssertionError('Rule consistentdim violated') + else: + return eval_consistentdim_wr + + +#################### + # ENTITY ifcmaterialclassificationrelationship # +#################### +class ifcmaterialclassificationrelationship(BaseEntityClass): + '''Entity ifcmaterialclassificationrelationship definition. + + :param materialclassifications + :type materialclassifications:SET(1,None,'ifcclassificationselect', scope = schema_scope) + + :param classifiedmaterial + :type classifiedmaterial:ifcmaterial + ''' + def __init__( self , materialclassifications,classifiedmaterial, ): + self.materialclassifications = materialclassifications + self.classifiedmaterial = classifiedmaterial + + @apply + def materialclassifications(): + def fget( self ): + return self._materialclassifications + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument materialclassifications is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcclassificationselect', scope = schema_scope)): + self._materialclassifications = SET(value) + else: + self._materialclassifications = value + return property(**locals()) + + @apply + def classifiedmaterial(): + def fget( self ): + return self._classifiedmaterial + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument classifiedmaterial is mantatory and can not be set to None') + if not check_type(value,ifcmaterial): + self._classifiedmaterial = ifcmaterial(value) + else: + self._classifiedmaterial = value + return property(**locals()) + +#################### + # ENTITY ifcrelconnectselements # +#################### +class ifcrelconnectselements(ifcrelconnects): + '''Entity ifcrelconnectselements definition. + + :param connectiongeometry + :type connectiongeometry:ifcconnectiongeometry + + :param relatingelement + :type relatingelement:ifcelement + + :param relatedelement + :type relatedelement:ifcelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , connectiongeometry,relatingelement,relatedelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.connectiongeometry = connectiongeometry + self.relatingelement = relatingelement + self.relatedelement = relatedelement + + @apply + def connectiongeometry(): + def fget( self ): + return self._connectiongeometry + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcconnectiongeometry): + self._connectiongeometry = ifcconnectiongeometry(value) + else: + self._connectiongeometry = value + else: + self._connectiongeometry = value + return property(**locals()) + + @apply + def relatingelement(): + def fget( self ): + return self._relatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingelement = ifcelement(value) + else: + self._relatingelement = value + return property(**locals()) + + @apply + def relatedelement(): + def fget( self ): + return self._relatedelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatedelement = ifcelement(value) + else: + self._relatedelement = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (self.relatingelement != self.relatedelement) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcshapeaspect # +#################### +class ifcshapeaspect(BaseEntityClass): + '''Entity ifcshapeaspect definition. + + :param shaperepresentations + :type shaperepresentations:LIST(1,None,'ifcshapemodel', scope = schema_scope) + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param productdefinitional + :type productdefinitional:LOGICAL + + :param partofproductdefinitionshape + :type partofproductdefinitionshape:ifcproductrepresentationselect + ''' + def __init__( self , shaperepresentations,name,description,productdefinitional,partofproductdefinitionshape, ): + self.shaperepresentations = shaperepresentations + self.name = name + self.description = description + self.productdefinitional = productdefinitional + self.partofproductdefinitionshape = partofproductdefinitionshape + + @apply + def shaperepresentations(): + def fget( self ): + return self._shaperepresentations + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument shaperepresentations is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcshapemodel', scope = schema_scope)): + self._shaperepresentations = LIST(value) + else: + self._shaperepresentations = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def productdefinitional(): + def fget( self ): + return self._productdefinitional + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument productdefinitional is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._productdefinitional = LOGICAL(value) + else: + self._productdefinitional = value + return property(**locals()) + + @apply + def partofproductdefinitionshape(): + def fget( self ): + return self._partofproductdefinitionshape + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcproductrepresentationselect): + self._partofproductdefinitionshape = ifcproductrepresentationselect(value) + else: + self._partofproductdefinitionshape = value + else: + self._partofproductdefinitionshape = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralcurveconnection # +#################### +class ifcstructuralcurveconnection(ifcstructuralconnection): + '''Entity ifcstructuralcurveconnection definition. + + :param axis + :type axis:ifcdirection + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , axis, ): + ifcstructuralconnection.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ) + self.axis = axis + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axis is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._axis = ifcdirection(value) + else: + self._axis = value + return property(**locals()) + +#################### + # ENTITY ifcushapeprofiledef # +#################### +class ifcushapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifcushapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param flangewidth + :type flangewidth:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param flangethickness + :type flangethickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcnonnegativelengthmeasure + + :param edgeradius + :type edgeradius:ifcnonnegativelengthmeasure + + :param flangeslope + :type flangeslope:ifcplaneanglemeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,flangewidth,webthickness,flangethickness,filletradius,edgeradius,flangeslope, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.flangewidth = flangewidth + self.webthickness = webthickness + self.flangethickness = flangethickness + self.filletradius = filletradius + self.edgeradius = edgeradius + self.flangeslope = flangeslope + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def flangewidth(): + def fget( self ): + return self._flangewidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangewidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangewidth = ifcpositivelengthmeasure(value) + else: + self._flangewidth = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def flangethickness(): + def fget( self ): + return self._flangethickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangethickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangethickness = ifcpositivelengthmeasure(value) + else: + self._flangethickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._filletradius = ifcnonnegativelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + + @apply + def edgeradius(): + def fget( self ): + return self._edgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._edgeradius = ifcnonnegativelengthmeasure(value) + else: + self._edgeradius = value + else: + self._edgeradius = value + return property(**locals()) + + @apply + def flangeslope(): + def fget( self ): + return self._flangeslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._flangeslope = ifcplaneanglemeasure(value) + else: + self._flangeslope = value + else: + self._flangeslope = value + return property(**locals()) + def validflangethickness(self): + eval_validflangethickness_wr = (self.flangethickness < (self.depth / 2)) + if not eval_validflangethickness_wr: + raise AssertionError('Rule validflangethickness violated') + else: + return eval_validflangethickness_wr + + def validwebthickness(self): + eval_validwebthickness_wr = (self.webthickness < self.flangewidth) + if not eval_validwebthickness_wr: + raise AssertionError('Rule validwebthickness violated') + else: + return eval_validwebthickness_wr + + +#################### + # ENTITY ifcelectricdistributionboard # +#################### +class ifcelectricdistributionboard(ifcflowcontroller): + '''Entity ifcelectricdistributionboard definition. + + :param predefinedtype + :type predefinedtype:ifcelectricdistributionboardtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowcontroller.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelectricdistributionboardtypeenum): + self._predefinedtype = ifcelectricdistributionboardtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcelectricdistributionboardtypeenum.self.userdefined)) or ((self.predefinedtype == ifcelectricdistributionboardtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCELECTRICDISTRIBUTIONBOARDTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcflowstoragedevice # +#################### +class ifcflowstoragedevice(ifcdistributionflowelement): + '''Entity ifcflowstoragedevice definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcelectricflowstoragedevice # +#################### +class ifcelectricflowstoragedevice(ifcflowstoragedevice): + '''Entity ifcelectricflowstoragedevice definition. + + :param predefinedtype + :type predefinedtype:ifcelectricflowstoragedevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowstoragedevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelectricflowstoragedevicetypeenum): + self._predefinedtype = ifcelectricflowstoragedevicetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcelectricflowstoragedevicetypeenum.self.userdefined)) or ((self.predefinedtype == ifcelectricflowstoragedevicetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCELECTRICFLOWSTORAGEDEVICETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcexternallydefinedsurfacestyle # +#################### +class ifcexternallydefinedsurfacestyle(ifcexternalreference): + '''Entity ifcexternallydefinedsurfacestyle definition. + ''' + def __init__( self , inherited0__location , inherited1__identification , inherited2__name , ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__identification , inherited2__name , ) + +#################### + # ENTITY ifcevaporatortype # +#################### +class ifcevaporatortype(ifcenergyconversiondevicetype): + '''Entity ifcevaporatortype definition. + + :param predefinedtype + :type predefinedtype:ifcevaporatortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcevaporatortypeenum): + self._predefinedtype = ifcevaporatortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcevaporatortypeenum.self.userdefined) or ((self.predefinedtype == ifcevaporatortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcrectangleprofiledef # +#################### +class ifcrectangleprofiledef(ifcparameterizedprofiledef): + '''Entity ifcrectangleprofiledef definition. + + :param xdim + :type xdim:ifcpositivelengthmeasure + + :param ydim + :type ydim:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , xdim,ydim, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.xdim = xdim + self.ydim = ydim + + @apply + def xdim(): + def fget( self ): + return self._xdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument xdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._xdim = ifcpositivelengthmeasure(value) + else: + self._xdim = value + return property(**locals()) + + @apply + def ydim(): + def fget( self ): + return self._ydim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ydim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ydim = ifcpositivelengthmeasure(value) + else: + self._ydim = value + return property(**locals()) + +#################### + # ENTITY ifcroundedrectangleprofiledef # +#################### +class ifcroundedrectangleprofiledef(ifcrectangleprofiledef): + '''Entity ifcroundedrectangleprofiledef definition. + + :param roundingradius + :type roundingradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__xdim , inherited4__ydim , roundingradius, ): + ifcrectangleprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__xdim , inherited4__ydim , ) + self.roundingradius = roundingradius + + @apply + def roundingradius(): + def fget( self ): + return self._roundingradius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument roundingradius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._roundingradius = ifcpositivelengthmeasure(value) + else: + self._roundingradius = value + return property(**locals()) + def validradius(self): + eval_validradius_wr = ((self.roundingradius <= (self.self.ifcrectangleprofiledef.self.xdim / 2)) and (self.roundingradius <= (self.self.ifcrectangleprofiledef.self.ydim / 2))) + if not eval_validradius_wr: + raise AssertionError('Rule validradius violated') + else: + return eval_validradius_wr + + +#################### + # ENTITY ifctshapeprofiledef # +#################### +class ifctshapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifctshapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param flangewidth + :type flangewidth:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param flangethickness + :type flangethickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcnonnegativelengthmeasure + + :param flangeedgeradius + :type flangeedgeradius:ifcnonnegativelengthmeasure + + :param webedgeradius + :type webedgeradius:ifcnonnegativelengthmeasure + + :param webslope + :type webslope:ifcplaneanglemeasure + + :param flangeslope + :type flangeslope:ifcplaneanglemeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,flangewidth,webthickness,flangethickness,filletradius,flangeedgeradius,webedgeradius,webslope,flangeslope, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.flangewidth = flangewidth + self.webthickness = webthickness + self.flangethickness = flangethickness + self.filletradius = filletradius + self.flangeedgeradius = flangeedgeradius + self.webedgeradius = webedgeradius + self.webslope = webslope + self.flangeslope = flangeslope + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def flangewidth(): + def fget( self ): + return self._flangewidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangewidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangewidth = ifcpositivelengthmeasure(value) + else: + self._flangewidth = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def flangethickness(): + def fget( self ): + return self._flangethickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangethickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangethickness = ifcpositivelengthmeasure(value) + else: + self._flangethickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._filletradius = ifcnonnegativelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + + @apply + def flangeedgeradius(): + def fget( self ): + return self._flangeedgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._flangeedgeradius = ifcnonnegativelengthmeasure(value) + else: + self._flangeedgeradius = value + else: + self._flangeedgeradius = value + return property(**locals()) + + @apply + def webedgeradius(): + def fget( self ): + return self._webedgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._webedgeradius = ifcnonnegativelengthmeasure(value) + else: + self._webedgeradius = value + else: + self._webedgeradius = value + return property(**locals()) + + @apply + def webslope(): + def fget( self ): + return self._webslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._webslope = ifcplaneanglemeasure(value) + else: + self._webslope = value + else: + self._webslope = value + return property(**locals()) + + @apply + def flangeslope(): + def fget( self ): + return self._flangeslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._flangeslope = ifcplaneanglemeasure(value) + else: + self._flangeslope = value + else: + self._flangeslope = value + return property(**locals()) + def validflangethickness(self): + eval_validflangethickness_wr = (self.flangethickness < self.depth) + if not eval_validflangethickness_wr: + raise AssertionError('Rule validflangethickness violated') + else: + return eval_validflangethickness_wr + + def validwebthickness(self): + eval_validwebthickness_wr = (self.webthickness < self.flangewidth) + if not eval_validwebthickness_wr: + raise AssertionError('Rule validwebthickness violated') + else: + return eval_validwebthickness_wr + + +#################### + # ENTITY ifcconstructionequipmentresourcetype # +#################### +class ifcconstructionequipmentresourcetype(ifcconstructionresourcetype): + '''Entity ifcconstructionequipmentresourcetype definition. + + :param predefinedtype + :type predefinedtype:ifcconstructionequipmentresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , predefinedtype, ): + ifcconstructionresourcetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcconstructionequipmentresourcetypeenum): + self._predefinedtype = ifcconstructionequipmentresourcetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcconstructionequipmentresourcetypeenum.self.userdefined) or ((self.predefinedtype == ifcconstructionequipmentresourcetypeenum.self.userdefined) and EXISTS(self.self.ifctyperesource.self.resourcetype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcelectricappliancetype # +#################### +class ifcelectricappliancetype(ifcflowterminaltype): + '''Entity ifcelectricappliancetype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricappliancetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricappliancetypeenum): + self._predefinedtype = ifcelectricappliancetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcelectricappliancetypeenum.self.userdefined) or ((self.predefinedtype == ifcelectricappliancetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcsystemfurnitureelement # +#################### +class ifcsystemfurnitureelement(ifcfurnishingelement): + '''Entity ifcsystemfurnitureelement definition. + + :param predefinedtype + :type predefinedtype:ifcsystemfurnitureelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcfurnishingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsystemfurnitureelementtypeenum): + self._predefinedtype = ifcsystemfurnitureelementtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcsystemfurnitureelementtypeenum.self.userdefined)) or ((self.predefinedtype == ifcsystemfurnitureelementtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSYSTEMFURNITUREELEMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifccondenser # +#################### +class ifccondenser(ifcenergyconversiondevice): + '''Entity ifccondenser definition. + + :param predefinedtype + :type predefinedtype:ifccondensertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccondensertypeenum): + self._predefinedtype = ifccondensertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccondensertypeenum.self.userdefined)) or ((self.predefinedtype == ifccondensertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCONDENSERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcgeographicelement # +#################### +class ifcgeographicelement(ifcelement): + '''Entity ifcgeographicelement definition. + + :param predefinedtype + :type predefinedtype:ifcgeographicelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcgeographicelementtypeenum): + self._predefinedtype = ifcgeographicelementtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcgeographicelementtypeenum.self.userdefined)) or ((self.predefinedtype == ifcgeographicelementtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCGEOGRAPHICELEMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifctextliteral # +#################### +class ifctextliteral(ifcgeometricrepresentationitem): + '''Entity ifctextliteral definition. + + :param literal + :type literal:ifcpresentabletext + + :param placement + :type placement:ifcaxis2placement + + :param path + :type path:ifctextpath + ''' + def __init__( self , literal,placement,path, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.literal = literal + self.placement = placement + self.path = path + + @apply + def literal(): + def fget( self ): + return self._literal + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument literal is mantatory and can not be set to None') + if not check_type(value,ifcpresentabletext): + self._literal = ifcpresentabletext(value) + else: + self._literal = value + return property(**locals()) + + @apply + def placement(): + def fget( self ): + return self._placement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placement is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._placement = ifcaxis2placement(value) + else: + self._placement = value + return property(**locals()) + + @apply + def path(): + def fget( self ): + return self._path + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument path is mantatory and can not be set to None') + if not check_type(value,ifctextpath): + self._path = ifctextpath(value) + else: + self._path = value + return property(**locals()) + +#################### + # ENTITY ifcexternalinformation # +#################### +class ifcexternalinformation(BaseEntityClass): + '''Entity ifcexternalinformation definition. + ''' + # This class does not define any attribute. + pass + +#################### + # ENTITY ifcdocumentinformation # +#################### +class ifcdocumentinformation(ifcexternalinformation): + '''Entity ifcdocumentinformation definition. + + :param identification + :type identification:ifcidentifier + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param location + :type location:ifcurireference + + :param purpose + :type purpose:ifctext + + :param intendeduse + :type intendeduse:ifctext + + :param scope + :type scope:ifctext + + :param revision + :type revision:ifclabel + + :param documentowner + :type documentowner:ifcactorselect + + :param editors + :type editors:SET(1,None,'ifcactorselect', scope = schema_scope) + + :param creationtime + :type creationtime:ifcdatetime + + :param lastrevisiontime + :type lastrevisiontime:ifcdatetime + + :param electronicformat + :type electronicformat:ifcidentifier + + :param validfrom + :type validfrom:ifcdate + + :param validuntil + :type validuntil:ifcdate + + :param confidentiality + :type confidentiality:ifcdocumentconfidentialityenum + + :param status + :type status:ifcdocumentstatusenum + + :param documentinfoforobjects + :type documentinfoforobjects:SET(0,None,'ifcrelassociatesdocument', scope = schema_scope) + + :param hasdocumentreferences + :type hasdocumentreferences:SET(0,None,'ifcdocumentreference', scope = schema_scope) + + :param ispointedto + :type ispointedto:SET(0,None,'ifcdocumentinformationrelationship', scope = schema_scope) + + :param ispointer + :type ispointer:SET(0,1,'ifcdocumentinformationrelationship', scope = schema_scope) + ''' + def __init__( self , identification,name,description,location,purpose,intendeduse,scope,revision,documentowner,editors,creationtime,lastrevisiontime,electronicformat,validfrom,validuntil,confidentiality,status, ): + ifcexternalinformation.__init__(self , ) + self.identification = identification + self.name = name + self.description = description + self.location = location + self.purpose = purpose + self.intendeduse = intendeduse + self.scope = scope + self.revision = revision + self.documentowner = documentowner + self.editors = editors + self.creationtime = creationtime + self.lastrevisiontime = lastrevisiontime + self.electronicformat = electronicformat + self.validfrom = validfrom + self.validuntil = validuntil + self.confidentiality = confidentiality + self.status = status + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument identification is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def location(): + def fget( self ): + return self._location + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcurireference): + self._location = ifcurireference(value) + else: + self._location = value + else: + self._location = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._purpose = ifctext(value) + else: + self._purpose = value + else: + self._purpose = value + return property(**locals()) + + @apply + def intendeduse(): + def fget( self ): + return self._intendeduse + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._intendeduse = ifctext(value) + else: + self._intendeduse = value + else: + self._intendeduse = value + return property(**locals()) + + @apply + def scope(): + def fget( self ): + return self._scope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._scope = ifctext(value) + else: + self._scope = value + else: + self._scope = value + return property(**locals()) + + @apply + def revision(): + def fget( self ): + return self._revision + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._revision = ifclabel(value) + else: + self._revision = value + else: + self._revision = value + return property(**locals()) + + @apply + def documentowner(): + def fget( self ): + return self._documentowner + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._documentowner = ifcactorselect(value) + else: + self._documentowner = value + else: + self._documentowner = value + return property(**locals()) + + @apply + def editors(): + def fget( self ): + return self._editors + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcactorselect', scope = schema_scope)): + self._editors = SET(value) + else: + self._editors = value + else: + self._editors = value + return property(**locals()) + + @apply + def creationtime(): + def fget( self ): + return self._creationtime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._creationtime = ifcdatetime(value) + else: + self._creationtime = value + else: + self._creationtime = value + return property(**locals()) + + @apply + def lastrevisiontime(): + def fget( self ): + return self._lastrevisiontime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._lastrevisiontime = ifcdatetime(value) + else: + self._lastrevisiontime = value + else: + self._lastrevisiontime = value + return property(**locals()) + + @apply + def electronicformat(): + def fget( self ): + return self._electronicformat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._electronicformat = ifcidentifier(value) + else: + self._electronicformat = value + else: + self._electronicformat = value + return property(**locals()) + + @apply + def validfrom(): + def fget( self ): + return self._validfrom + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdate): + self._validfrom = ifcdate(value) + else: + self._validfrom = value + else: + self._validfrom = value + return property(**locals()) + + @apply + def validuntil(): + def fget( self ): + return self._validuntil + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdate): + self._validuntil = ifcdate(value) + else: + self._validuntil = value + else: + self._validuntil = value + return property(**locals()) + + @apply + def confidentiality(): + def fget( self ): + return self._confidentiality + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdocumentconfidentialityenum): + self._confidentiality = ifcdocumentconfidentialityenum(value) + else: + self._confidentiality = value + else: + self._confidentiality = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdocumentstatusenum): + self._status = ifcdocumentstatusenum(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def documentinfoforobjects(): + def fget( self ): + return self._documentinfoforobjects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument documentinfoforobjects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasdocumentreferences(): + def fget( self ): + return self._hasdocumentreferences + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasdocumentreferences is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ispointedto(): + def fget( self ): + return self._ispointedto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ispointedto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ispointer(): + def fget( self ): + return self._ispointer + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ispointer is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcreinforcingbartype # +#################### +class ifcreinforcingbartype(ifcreinforcingelementtype): + '''Entity ifcreinforcingbartype definition. + + :param predefinedtype + :type predefinedtype:ifcreinforcingbartypeenum + + :param nominaldiameter + :type nominaldiameter:ifcpositivelengthmeasure + + :param crosssectionarea + :type crosssectionarea:ifcareameasure + + :param barlength + :type barlength:ifcpositivelengthmeasure + + :param barsurface + :type barsurface:ifcreinforcingbarsurfaceenum + + :param bendingshapecode + :type bendingshapecode:ifclabel + + :param bendingparameters + :type bendingparameters:LIST(1,None,'ifcbendingparameterselect', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype,nominaldiameter,crosssectionarea,barlength,barsurface,bendingshapecode,bendingparameters, ): + ifcreinforcingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + self.nominaldiameter = nominaldiameter + self.crosssectionarea = crosssectionarea + self.barlength = barlength + self.barsurface = barsurface + self.bendingshapecode = bendingshapecode + self.bendingparameters = bendingparameters + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcreinforcingbartypeenum): + self._predefinedtype = ifcreinforcingbartypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def nominaldiameter(): + def fget( self ): + return self._nominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominaldiameter = ifcpositivelengthmeasure(value) + else: + self._nominaldiameter = value + else: + self._nominaldiameter = value + return property(**locals()) + + @apply + def crosssectionarea(): + def fget( self ): + return self._crosssectionarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._crosssectionarea = ifcareameasure(value) + else: + self._crosssectionarea = value + else: + self._crosssectionarea = value + return property(**locals()) + + @apply + def barlength(): + def fget( self ): + return self._barlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._barlength = ifcpositivelengthmeasure(value) + else: + self._barlength = value + else: + self._barlength = value + return property(**locals()) + + @apply + def barsurface(): + def fget( self ): + return self._barsurface + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreinforcingbarsurfaceenum): + self._barsurface = ifcreinforcingbarsurfaceenum(value) + else: + self._barsurface = value + else: + self._barsurface = value + return property(**locals()) + + @apply + def bendingshapecode(): + def fget( self ): + return self._bendingshapecode + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._bendingshapecode = ifclabel(value) + else: + self._bendingshapecode = value + else: + self._bendingshapecode = value + return property(**locals()) + + @apply + def bendingparameters(): + def fget( self ): + return self._bendingparameters + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcbendingparameterselect', scope = schema_scope)): + self._bendingparameters = LIST(value) + else: + self._bendingparameters = value + else: + self._bendingparameters = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcreinforcingbartypeenum.self.userdefined) or ((self.predefinedtype == ifcreinforcingbartypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def bendingshapecodeprovided(self): + eval_bendingshapecodeprovided_wr = (( not EXISTS(self.bendingparameters)) or EXISTS(self.bendingshapecode)) + if not eval_bendingshapecodeprovided_wr: + raise AssertionError('Rule bendingshapecodeprovided violated') + else: + return eval_bendingshapecodeprovided_wr + + +#################### + # ENTITY ifcstylemodel # +#################### +class ifcstylemodel(ifcrepresentation): + '''Entity ifcstylemodel definition. + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcrepresentation.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + +#################### + # ENTITY ifcstyledrepresentation # +#################### +class ifcstyledrepresentation(ifcstylemodel): + '''Entity ifcstyledrepresentation definition. + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcstylemodel.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + def onlystyleditems(self): + eval_onlystyleditems_wr = (SIZEOF(None) == 0) + if not eval_onlystyleditems_wr: + raise AssertionError('Rule onlystyleditems violated') + else: + return eval_onlystyleditems_wr + + +#################### + # ENTITY ifcellipseprofiledef # +#################### +class ifcellipseprofiledef(ifcparameterizedprofiledef): + '''Entity ifcellipseprofiledef definition. + + :param semiaxis1 + :type semiaxis1:ifcpositivelengthmeasure + + :param semiaxis2 + :type semiaxis2:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , semiaxis1,semiaxis2, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.semiaxis1 = semiaxis1 + self.semiaxis2 = semiaxis2 + + @apply + def semiaxis1(): + def fget( self ): + return self._semiaxis1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semiaxis1 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._semiaxis1 = ifcpositivelengthmeasure(value) + else: + self._semiaxis1 = value + return property(**locals()) + + @apply + def semiaxis2(): + def fget( self ): + return self._semiaxis2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semiaxis2 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._semiaxis2 = ifcpositivelengthmeasure(value) + else: + self._semiaxis2 = value + return property(**locals()) + +#################### + # ENTITY ifcsectionedspine # +#################### +class ifcsectionedspine(ifcgeometricrepresentationitem): + '''Entity ifcsectionedspine definition. + + :param spinecurve + :type spinecurve:ifccompositecurve + + :param crosssections + :type crosssections:LIST(2,None,'ifcprofiledef', scope = schema_scope) + + :param crosssectionpositions + :type crosssectionpositions:LIST(2,None,'ifcaxis2placement3d', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , spinecurve,crosssections,crosssectionpositions, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.spinecurve = spinecurve + self.crosssections = crosssections + self.crosssectionpositions = crosssectionpositions + + @apply + def spinecurve(): + def fget( self ): + return self._spinecurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument spinecurve is mantatory and can not be set to None') + if not check_type(value,ifccompositecurve): + self._spinecurve = ifccompositecurve(value) + else: + self._spinecurve = value + return property(**locals()) + + @apply + def crosssections(): + def fget( self ): + return self._crosssections + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument crosssections is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'ifcprofiledef', scope = schema_scope)): + self._crosssections = LIST(value) + else: + self._crosssections = value + return property(**locals()) + + @apply + def crosssectionpositions(): + def fget( self ): + return self._crosssectionpositions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument crosssectionpositions is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'ifcaxis2placement3d', scope = schema_scope)): + self._crosssectionpositions = LIST(value) + else: + self._crosssectionpositions = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def correspondingsectionpositions(self): + eval_correspondingsectionpositions_wr = (SIZEOF(self.crosssections) == SIZEOF(self.crosssectionpositions)) + if not eval_correspondingsectionpositions_wr: + raise AssertionError('Rule correspondingsectionpositions violated') + else: + return eval_correspondingsectionpositions_wr + + def consistentprofiletypes(self): + eval_consistentprofiletypes_wr = (SIZEOF(None) == 0) + if not eval_consistentprofiletypes_wr: + raise AssertionError('Rule consistentprofiletypes violated') + else: + return eval_consistentprofiletypes_wr + + def spinecurvedim(self): + eval_spinecurvedim_wr = (self.spinecurve.self.dim == 3) + if not eval_spinecurvedim_wr: + raise AssertionError('Rule spinecurvedim violated') + else: + return eval_spinecurvedim_wr + + +#################### + # ENTITY ifcvertex # +#################### +class ifcvertex(ifctopologicalrepresentationitem): + '''Entity ifcvertex definition. + ''' + def __init__( self , ): + ifctopologicalrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifcvertexpoint # +#################### +class ifcvertexpoint(ifcvertex): + '''Entity ifcvertexpoint definition. + + :param vertexgeometry + :type vertexgeometry:ifcpoint + ''' + def __init__( self , vertexgeometry, ): + ifcvertex.__init__(self , ) + self.vertexgeometry = vertexgeometry + + @apply + def vertexgeometry(): + def fget( self ): + return self._vertexgeometry + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vertexgeometry is mantatory and can not be set to None') + if not check_type(value,ifcpoint): + self._vertexgeometry = ifcpoint(value) + else: + self._vertexgeometry = value + return property(**locals()) + +#################### + # ENTITY ifcwallstandardcase # +#################### +class ifcwallstandardcase(ifcwall): + '''Entity ifcwallstandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ): + ifcwall.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ) + def hasmateriallayersetusage(self): + eval_hasmateriallayersetusage_wr = (SIZEOF(None) == 1) + if not eval_hasmateriallayersetusage_wr: + raise AssertionError('Rule hasmateriallayersetusage violated') + else: + return eval_hasmateriallayersetusage_wr + + +#################### + # ENTITY ifccoolingtower # +#################### +class ifccoolingtower(ifcenergyconversiondevice): + '''Entity ifccoolingtower definition. + + :param predefinedtype + :type predefinedtype:ifccoolingtowertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccoolingtowertypeenum): + self._predefinedtype = ifccoolingtowertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccoolingtowertypeenum.self.userdefined)) or ((self.predefinedtype == ifccoolingtowertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCOOLINGTOWERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcswitchingdevice # +#################### +class ifcswitchingdevice(ifcflowcontroller): + '''Entity ifcswitchingdevice definition. + + :param predefinedtype + :type predefinedtype:ifcswitchingdevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowcontroller.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcswitchingdevicetypeenum): + self._predefinedtype = ifcswitchingdevicetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcswitchingdevicetypeenum.self.userdefined)) or ((self.predefinedtype == ifcswitchingdevicetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSWITCHINGDEVICETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcfeatureelementsubtraction # +#################### +class ifcfeatureelementsubtraction(ifcfeatureelement): + '''Entity ifcfeatureelementsubtraction definition. + + :param voidselements + :type voidselements:ifcrelvoidselement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcfeatureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + + @apply + def voidselements(): + def fget( self ): + return self._voidselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument voidselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def hasnosubtraction(self): + eval_hasnosubtraction_wr = (SIZEOF(self.self.ifcelement.self.hasopenings) == 0) + if not eval_hasnosubtraction_wr: + raise AssertionError('Rule hasnosubtraction violated') + else: + return eval_hasnosubtraction_wr + + def isnotfilling(self): + eval_isnotfilling_wr = (SIZEOF(self.self.ifcelement.self.fillsvoids) == 0) + if not eval_isnotfilling_wr: + raise AssertionError('Rule isnotfilling violated') + else: + return eval_isnotfilling_wr + + +#################### + # ENTITY ifcvoidingfeature # +#################### +class ifcvoidingfeature(ifcfeatureelementsubtraction): + '''Entity ifcvoidingfeature definition. + + :param predefinedtype + :type predefinedtype:ifcvoidingfeaturetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcfeatureelementsubtraction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvoidingfeaturetypeenum): + self._predefinedtype = ifcvoidingfeaturetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def hasobjecttype(self): + eval_hasobjecttype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcvoidingfeaturetypeenum.self.userdefined)) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + +#################### + # ENTITY ifccablecarriersegmenttype # +#################### +class ifccablecarriersegmenttype(ifcflowsegmenttype): + '''Entity ifccablecarriersegmenttype definition. + + :param predefinedtype + :type predefinedtype:ifccablecarriersegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowsegmenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccablecarriersegmenttypeenum): + self._predefinedtype = ifccablecarriersegmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccablecarriersegmenttypeenum.self.userdefined) or ((self.predefinedtype == ifccablecarriersegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcaudiovisualappliance # +#################### +class ifcaudiovisualappliance(ifcflowterminal): + '''Entity ifcaudiovisualappliance definition. + + :param predefinedtype + :type predefinedtype:ifcaudiovisualappliancetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaudiovisualappliancetypeenum): + self._predefinedtype = ifcaudiovisualappliancetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcaudiovisualappliancetypeenum.self.userdefined)) or ((self.predefinedtype == ifcaudiovisualappliancetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCAUDIOVISUALAPPLIANCETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcductsilencertype # +#################### +class ifcductsilencertype(ifcflowtreatmentdevicetype): + '''Entity ifcductsilencertype definition. + + :param predefinedtype + :type predefinedtype:ifcductsilencertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowtreatmentdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcductsilencertypeenum): + self._predefinedtype = ifcductsilencertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcductsilencertypeenum.self.userdefined) or ((self.predefinedtype == ifcductsilencertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcasymmetricishapeprofiledef # +#################### +class ifcasymmetricishapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifcasymmetricishapeprofiledef definition. + + :param bottomflangewidth + :type bottomflangewidth:ifcpositivelengthmeasure + + :param overalldepth + :type overalldepth:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param bottomflangethickness + :type bottomflangethickness:ifcpositivelengthmeasure + + :param bottomflangefilletradius + :type bottomflangefilletradius:ifcnonnegativelengthmeasure + + :param topflangewidth + :type topflangewidth:ifcpositivelengthmeasure + + :param topflangethickness + :type topflangethickness:ifcpositivelengthmeasure + + :param topflangefilletradius + :type topflangefilletradius:ifcnonnegativelengthmeasure + + :param bottomflangeedgeradius + :type bottomflangeedgeradius:ifcnonnegativelengthmeasure + + :param bottomflangeslope + :type bottomflangeslope:ifcplaneanglemeasure + + :param topflangeedgeradius + :type topflangeedgeradius:ifcnonnegativelengthmeasure + + :param topflangeslope + :type topflangeslope:ifcplaneanglemeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , bottomflangewidth,overalldepth,webthickness,bottomflangethickness,bottomflangefilletradius,topflangewidth,topflangethickness,topflangefilletradius,bottomflangeedgeradius,bottomflangeslope,topflangeedgeradius,topflangeslope, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.bottomflangewidth = bottomflangewidth + self.overalldepth = overalldepth + self.webthickness = webthickness + self.bottomflangethickness = bottomflangethickness + self.bottomflangefilletradius = bottomflangefilletradius + self.topflangewidth = topflangewidth + self.topflangethickness = topflangethickness + self.topflangefilletradius = topflangefilletradius + self.bottomflangeedgeradius = bottomflangeedgeradius + self.bottomflangeslope = bottomflangeslope + self.topflangeedgeradius = topflangeedgeradius + self.topflangeslope = topflangeslope + + @apply + def bottomflangewidth(): + def fget( self ): + return self._bottomflangewidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bottomflangewidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._bottomflangewidth = ifcpositivelengthmeasure(value) + else: + self._bottomflangewidth = value + return property(**locals()) + + @apply + def overalldepth(): + def fget( self ): + return self._overalldepth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument overalldepth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._overalldepth = ifcpositivelengthmeasure(value) + else: + self._overalldepth = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def bottomflangethickness(): + def fget( self ): + return self._bottomflangethickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bottomflangethickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._bottomflangethickness = ifcpositivelengthmeasure(value) + else: + self._bottomflangethickness = value + return property(**locals()) + + @apply + def bottomflangefilletradius(): + def fget( self ): + return self._bottomflangefilletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._bottomflangefilletradius = ifcnonnegativelengthmeasure(value) + else: + self._bottomflangefilletradius = value + else: + self._bottomflangefilletradius = value + return property(**locals()) + + @apply + def topflangewidth(): + def fget( self ): + return self._topflangewidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument topflangewidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._topflangewidth = ifcpositivelengthmeasure(value) + else: + self._topflangewidth = value + return property(**locals()) + + @apply + def topflangethickness(): + def fget( self ): + return self._topflangethickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._topflangethickness = ifcpositivelengthmeasure(value) + else: + self._topflangethickness = value + else: + self._topflangethickness = value + return property(**locals()) + + @apply + def topflangefilletradius(): + def fget( self ): + return self._topflangefilletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._topflangefilletradius = ifcnonnegativelengthmeasure(value) + else: + self._topflangefilletradius = value + else: + self._topflangefilletradius = value + return property(**locals()) + + @apply + def bottomflangeedgeradius(): + def fget( self ): + return self._bottomflangeedgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._bottomflangeedgeradius = ifcnonnegativelengthmeasure(value) + else: + self._bottomflangeedgeradius = value + else: + self._bottomflangeedgeradius = value + return property(**locals()) + + @apply + def bottomflangeslope(): + def fget( self ): + return self._bottomflangeslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._bottomflangeslope = ifcplaneanglemeasure(value) + else: + self._bottomflangeslope = value + else: + self._bottomflangeslope = value + return property(**locals()) + + @apply + def topflangeedgeradius(): + def fget( self ): + return self._topflangeedgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._topflangeedgeradius = ifcnonnegativelengthmeasure(value) + else: + self._topflangeedgeradius = value + else: + self._topflangeedgeradius = value + return property(**locals()) + + @apply + def topflangeslope(): + def fget( self ): + return self._topflangeslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._topflangeslope = ifcplaneanglemeasure(value) + else: + self._topflangeslope = value + else: + self._topflangeslope = value + return property(**locals()) + def validflangethickness(self): + eval_validflangethickness_wr = (( not EXISTS(self.topflangethickness)) or ((self.bottomflangethickness + self.topflangethickness) < self.overalldepth)) + if not eval_validflangethickness_wr: + raise AssertionError('Rule validflangethickness violated') + else: + return eval_validflangethickness_wr + + def validwebthickness(self): + eval_validwebthickness_wr = ((self.webthickness < self.bottomflangewidth) and (self.webthickness < self.topflangewidth)) + if not eval_validwebthickness_wr: + raise AssertionError('Rule validwebthickness violated') + else: + return eval_validwebthickness_wr + + def validbottomfilletradius(self): + eval_validbottomfilletradius_wr = (( not EXISTS(self.bottomflangefilletradius)) or (self.bottomflangefilletradius <= ((self.bottomflangewidth - self.webthickness) / 2))) + if not eval_validbottomfilletradius_wr: + raise AssertionError('Rule validbottomfilletradius violated') + else: + return eval_validbottomfilletradius_wr + + def validtopfilletradius(self): + eval_validtopfilletradius_wr = (( not EXISTS(self.topflangefilletradius)) or (self.topflangefilletradius <= ((self.topflangewidth - self.webthickness) / 2))) + if not eval_validtopfilletradius_wr: + raise AssertionError('Rule validtopfilletradius violated') + else: + return eval_validtopfilletradius_wr + + +#################### + # ENTITY ifcstructuralcurveaction # +#################### +class ifcstructuralcurveaction(ifcstructuralaction): + '''Entity ifcstructuralcurveaction definition. + + :param projectedortrue + :type projectedortrue:ifcprojectedortruelengthenum + + :param predefinedtype + :type predefinedtype:ifcstructuralcurveactivitytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , projectedortrue,predefinedtype, ): + ifcstructuralaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , ) + self.projectedortrue = projectedortrue + self.predefinedtype = predefinedtype + + @apply + def projectedortrue(): + def fget( self ): + return self._projectedortrue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcprojectedortruelengthenum): + self._projectedortrue = ifcprojectedortruelengthenum(value) + else: + self._projectedortrue = value + else: + self._projectedortrue = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstructuralcurveactivitytypeenum): + self._predefinedtype = ifcstructuralcurveactivitytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def projectedisglobal(self): + eval_projectedisglobal_wr = (( not EXISTS(self.projectedortrue)) or ((self.projectedortrue != projected_length) or (self.self.ifcstructuralactivity.self.globalorlocal == global_coords))) + if not eval_projectedisglobal_wr: + raise AssertionError('Rule projectedisglobal violated') + else: + return eval_projectedisglobal_wr + + def hasobjecttype(self): + eval_hasobjecttype_wr = ((self.predefinedtype != ifcstructuralcurveactivitytypeenum.self.userdefined) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + def suitablepredefinedtype(self): + eval_suitablepredefinedtype_wr = (self.predefinedtype != ifcstructuralcurveactivitytypeenum.self.equidistant) + if not eval_suitablepredefinedtype_wr: + raise AssertionError('Rule suitablepredefinedtype violated') + else: + return eval_suitablepredefinedtype_wr + + +#################### + # ENTITY ifccartesiantransformationoperator2d # +#################### +class ifccartesiantransformationoperator2d(ifccartesiantransformationoperator): + '''Entity ifccartesiantransformationoperator2d definition. + + :param u + :type u:LIST(2,2,'ifcdirection', scope = schema_scope) + ''' + def __init__( self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , ): + ifccartesiantransformationoperator.__init__(self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , ) + + @apply + def u(): + def fget( self ): + attribute_eval = ifcbaseaxis(2,self.self.ifccartesiantransformationoperator.self.axis1,self.self.ifccartesiantransformationoperator.self.axis2, None ) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument u is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def dimequal2(self): + eval_dimequal2_wr = (self.self.ifccartesiantransformationoperator.self.dim == 2) + if not eval_dimequal2_wr: + raise AssertionError('Rule dimequal2 violated') + else: + return eval_dimequal2_wr + + def axis1is2d(self): + eval_axis1is2d_wr = (( not EXISTS(self.self.ifccartesiantransformationoperator.self.axis1)) or (self.self.ifccartesiantransformationoperator.self.axis1.self.dim == 2)) + if not eval_axis1is2d_wr: + raise AssertionError('Rule axis1is2d violated') + else: + return eval_axis1is2d_wr + + def axis2is2d(self): + eval_axis2is2d_wr = (( not EXISTS(self.self.ifccartesiantransformationoperator.self.axis2)) or (self.self.ifccartesiantransformationoperator.self.axis2.self.dim == 2)) + if not eval_axis2is2d_wr: + raise AssertionError('Rule axis2is2d violated') + else: + return eval_axis2is2d_wr + + +#################### + # ENTITY ifccartesiantransformationoperator2dnonuniform # +#################### +class ifccartesiantransformationoperator2dnonuniform(ifccartesiantransformationoperator2d): + '''Entity ifccartesiantransformationoperator2dnonuniform definition. + + :param scale2 + :type scale2:REAL + + :param scl2 + :type scl2:REAL + ''' + def __init__( self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , scale2, ): + ifccartesiantransformationoperator2d.__init__(self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , ) + self.scale2 = scale2 + + @apply + def scale2(): + def fget( self ): + return self._scale2 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._scale2 = REAL(value) + else: + self._scale2 = value + else: + self._scale2 = value + return property(**locals()) + + @apply + def scl2(): + def fget( self ): + attribute_eval = NVL(self.scale2,self.self.ifccartesiantransformationoperator.self.scl) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scl2 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def scale2greaterzero(self): + eval_scale2greaterzero_wr = (self.scl2 > 0) + if not eval_scale2greaterzero_wr: + raise AssertionError('Rule scale2greaterzero violated') + else: + return eval_scale2greaterzero_wr + + +#################### + # ENTITY ifcelementassembly # +#################### +class ifcelementassembly(ifcelement): + '''Entity ifcelementassembly definition. + + :param assemblyplace + :type assemblyplace:ifcassemblyplaceenum + + :param predefinedtype + :type predefinedtype:ifcelementassemblytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , assemblyplace,predefinedtype, ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.assemblyplace = assemblyplace + self.predefinedtype = predefinedtype + + @apply + def assemblyplace(): + def fget( self ): + return self._assemblyplace + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcassemblyplaceenum): + self._assemblyplace = ifcassemblyplaceenum(value) + else: + self._assemblyplace = value + else: + self._assemblyplace = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelementassemblytypeenum): + self._predefinedtype = ifcelementassemblytypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcelementassemblytypeenum.self.userdefined)) or ((self.predefinedtype == ifcelementassemblytypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCELEMENTASSEMBLYTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcelementcomponent # +#################### +class ifcelementcomponent(ifcelement): + '''Entity ifcelementcomponent definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifcsweptdisksolid # +#################### +class ifcsweptdisksolid(ifcsolidmodel): + '''Entity ifcsweptdisksolid definition. + + :param directrix + :type directrix:ifccurve + + :param radius + :type radius:ifcpositivelengthmeasure + + :param innerradius + :type innerradius:ifcpositivelengthmeasure + + :param startparam + :type startparam:ifcparametervalue + + :param endparam + :type endparam:ifcparametervalue + ''' + def __init__( self , directrix,radius,innerradius,startparam,endparam, ): + ifcsolidmodel.__init__(self , ) + self.directrix = directrix + self.radius = radius + self.innerradius = innerradius + self.startparam = startparam + self.endparam = endparam + + @apply + def directrix(): + def fget( self ): + return self._directrix + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directrix is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._directrix = ifccurve(value) + else: + self._directrix = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + + @apply + def innerradius(): + def fget( self ): + return self._innerradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._innerradius = ifcpositivelengthmeasure(value) + else: + self._innerradius = value + else: + self._innerradius = value + return property(**locals()) + + @apply + def startparam(): + def fget( self ): + return self._startparam + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcparametervalue): + self._startparam = ifcparametervalue(value) + else: + self._startparam = value + else: + self._startparam = value + return property(**locals()) + + @apply + def endparam(): + def fget( self ): + return self._endparam + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcparametervalue): + self._endparam = ifcparametervalue(value) + else: + self._endparam = value + else: + self._endparam = value + return property(**locals()) + def directrixdim(self): + eval_directrixdim_wr = (self.directrix.self.dim == 3) + if not eval_directrixdim_wr: + raise AssertionError('Rule directrixdim violated') + else: + return eval_directrixdim_wr + + def innerradiussize(self): + eval_innerradiussize_wr = (( not EXISTS(self.innerradius)) or (self.radius > self.innerradius)) + if not eval_innerradiussize_wr: + raise AssertionError('Rule innerradiussize violated') + else: + return eval_innerradiussize_wr + + def directrixbounded(self): + eval_directrixbounded_wr = ((EXISTS(self.startparam) and EXISTS(self.endparam)) or (SIZEOF(['IFC4.IFCCONIC','IFC4.IFCBOUNDEDCURVE'] * TYPEOF(self.directrix)) == 1)) + if not eval_directrixbounded_wr: + raise AssertionError('Rule directrixbounded violated') + else: + return eval_directrixbounded_wr + + +#################### + # ENTITY ifcsweptdisksolidpolygonal # +#################### +class ifcsweptdisksolidpolygonal(ifcsweptdisksolid): + '''Entity ifcsweptdisksolidpolygonal definition. + + :param filletradius + :type filletradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__directrix , inherited1__radius , inherited2__innerradius , inherited3__startparam , inherited4__endparam , filletradius, ): + ifcsweptdisksolid.__init__(self , inherited0__directrix , inherited1__radius , inherited2__innerradius , inherited3__startparam , inherited4__endparam , ) + self.filletradius = filletradius + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._filletradius = ifcpositivelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + def correctradii(self): + eval_correctradii_wr = (( not EXISTS(self.filletradius)) or (self.filletradius >= self.self.ifcsweptdisksolid.self.radius)) + if not eval_correctradii_wr: + raise AssertionError('Rule correctradii violated') + else: + return eval_correctradii_wr + + def directrixispolyline(self): + eval_directrixispolyline_wr = ('IFC4.IFCPOLYLINE' == TYPEOF(self.self.ifcsweptdisksolid.self.directrix)) + if not eval_directrixispolyline_wr: + raise AssertionError('Rule directrixispolyline violated') + else: + return eval_directrixispolyline_wr + + +#################### + # ENTITY ifcaddress # +#################### +class ifcaddress(BaseEntityClass): + '''Entity ifcaddress definition. + + :param purpose + :type purpose:ifcaddresstypeenum + + :param description + :type description:ifctext + + :param userdefinedpurpose + :type userdefinedpurpose:ifclabel + + :param ofperson + :type ofperson:SET(0,None,'ifcperson', scope = schema_scope) + + :param oforganization + :type oforganization:SET(0,None,'ifcorganization', scope = schema_scope) + ''' + def __init__( self , purpose,description,userdefinedpurpose, ): + self.purpose = purpose + self.description = description + self.userdefinedpurpose = userdefinedpurpose + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaddresstypeenum): + self._purpose = ifcaddresstypeenum(value) + else: + self._purpose = value + else: + self._purpose = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def userdefinedpurpose(): + def fget( self ): + return self._userdefinedpurpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedpurpose = ifclabel(value) + else: + self._userdefinedpurpose = value + else: + self._userdefinedpurpose = value + return property(**locals()) + + @apply + def ofperson(): + def fget( self ): + return self._ofperson + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ofperson is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def oforganization(): + def fget( self ): + return self._oforganization + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument oforganization is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (( not EXISTS(self.purpose)) or ((self.purpose != ifcaddresstypeenum.self.userdefined) or ((self.purpose == ifcaddresstypeenum.self.userdefined) and EXISTS(self.self.userdefinedpurpose)))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifctelecomaddress # +#################### +class ifctelecomaddress(ifcaddress): + '''Entity ifctelecomaddress definition. + + :param telephonenumbers + :type telephonenumbers:LIST(1,None,'STRING', scope = schema_scope) + + :param facsimilenumbers + :type facsimilenumbers:LIST(1,None,'STRING', scope = schema_scope) + + :param pagernumber + :type pagernumber:ifclabel + + :param electronicmailaddresses + :type electronicmailaddresses:LIST(1,None,'STRING', scope = schema_scope) + + :param wwwhomepageurl + :type wwwhomepageurl:ifcurireference + + :param messagingids + :type messagingids:LIST(1,None,'STRING', scope = schema_scope) + ''' + def __init__( self , inherited0__purpose , inherited1__description , inherited2__userdefinedpurpose , telephonenumbers,facsimilenumbers,pagernumber,electronicmailaddresses,wwwhomepageurl,messagingids, ): + ifcaddress.__init__(self , inherited0__purpose , inherited1__description , inherited2__userdefinedpurpose , ) + self.telephonenumbers = telephonenumbers + self.facsimilenumbers = facsimilenumbers + self.pagernumber = pagernumber + self.electronicmailaddresses = electronicmailaddresses + self.wwwhomepageurl = wwwhomepageurl + self.messagingids = messagingids + + @apply + def telephonenumbers(): + def fget( self ): + return self._telephonenumbers + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._telephonenumbers = LIST(value) + else: + self._telephonenumbers = value + else: + self._telephonenumbers = value + return property(**locals()) + + @apply + def facsimilenumbers(): + def fget( self ): + return self._facsimilenumbers + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._facsimilenumbers = LIST(value) + else: + self._facsimilenumbers = value + else: + self._facsimilenumbers = value + return property(**locals()) + + @apply + def pagernumber(): + def fget( self ): + return self._pagernumber + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._pagernumber = ifclabel(value) + else: + self._pagernumber = value + else: + self._pagernumber = value + return property(**locals()) + + @apply + def electronicmailaddresses(): + def fget( self ): + return self._electronicmailaddresses + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._electronicmailaddresses = LIST(value) + else: + self._electronicmailaddresses = value + else: + self._electronicmailaddresses = value + return property(**locals()) + + @apply + def wwwhomepageurl(): + def fget( self ): + return self._wwwhomepageurl + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcurireference): + self._wwwhomepageurl = ifcurireference(value) + else: + self._wwwhomepageurl = value + else: + self._wwwhomepageurl = value + return property(**locals()) + + @apply + def messagingids(): + def fget( self ): + return self._messagingids + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._messagingids = LIST(value) + else: + self._messagingids = value + else: + self._messagingids = value + return property(**locals()) + def minimumdataprovided(self): + eval_minimumdataprovided_wr = (((((EXISTS(self.telephonenumbers) or EXISTS(self.facsimilenumbers)) or EXISTS(self.pagernumber)) or EXISTS(self.electronicmailaddresses)) or EXISTS(self.wwwhomepageurl)) or EXISTS(self.messagingids)) + if not eval_minimumdataprovided_wr: + raise AssertionError('Rule minimumdataprovided violated') + else: + return eval_minimumdataprovided_wr + + +#################### + # ENTITY ifccurvestylefontandscaling # +#################### +class ifccurvestylefontandscaling(ifcpresentationitem): + '''Entity ifccurvestylefontandscaling definition. + + :param name + :type name:ifclabel + + :param curvefont + :type curvefont:ifccurvestylefontselect + + :param curvefontscaling + :type curvefontscaling:ifcpositiveratiomeasure + ''' + def __init__( self , name,curvefont,curvefontscaling, ): + ifcpresentationitem.__init__(self , ) + self.name = name + self.curvefont = curvefont + self.curvefontscaling = curvefontscaling + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def curvefont(): + def fget( self ): + return self._curvefont + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curvefont is mantatory and can not be set to None') + if not check_type(value,ifccurvestylefontselect): + self._curvefont = ifccurvestylefontselect(value) + else: + self._curvefont = value + return property(**locals()) + + @apply + def curvefontscaling(): + def fget( self ): + return self._curvefontscaling + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curvefontscaling is mantatory and can not be set to None') + if not check_type(value,ifcpositiveratiomeasure): + self._curvefontscaling = ifcpositiveratiomeasure(value) + else: + self._curvefontscaling = value + return property(**locals()) + +#################### + # ENTITY ifcspatialelement # +#################### +class ifcspatialelement(ifcproduct): + '''Entity ifcspatialelement definition. + + :param longname + :type longname:ifclabel + + :param containselements + :type containselements:SET(0,None,'ifcrelcontainedinspatialstructure', scope = schema_scope) + + :param servicedbysystems + :type servicedbysystems:SET(0,None,'ifcrelservicesbuildings', scope = schema_scope) + + :param referenceselements + :type referenceselements:SET(0,None,'ifcrelreferencedinspatialstructure', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , longname, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.longname = longname + + @apply + def longname(): + def fget( self ): + return self._longname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._longname = ifclabel(value) + else: + self._longname = value + else: + self._longname = value + return property(**locals()) + + @apply + def containselements(): + def fget( self ): + return self._containselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def servicedbysystems(): + def fget( self ): + return self._servicedbysystems + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument servicedbysystems is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def referenceselements(): + def fget( self ): + return self._referenceselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referenceselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcexternalspatialstructureelement # +#################### +class ifcexternalspatialstructureelement(ifcspatialelement): + '''Entity ifcexternalspatialstructureelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , ): + ifcspatialelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , ) + +#################### + # ENTITY ifcexternalspatialelement # +#################### +class ifcexternalspatialelement(ifcexternalspatialstructureelement): + '''Entity ifcexternalspatialelement definition. + + :param predefinedtype + :type predefinedtype:ifcexternalspatialelementtypeenum + + :param boundedby + :type boundedby:SET(0,None,'ifcrelspaceboundary', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , predefinedtype, ): + ifcexternalspatialstructureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcexternalspatialelementtypeenum): + self._predefinedtype = ifcexternalspatialelementtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def boundedby(): + def fget( self ): + return self._boundedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument boundedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsurfaceoflinearextrusion # +#################### +class ifcsurfaceoflinearextrusion(ifcsweptsurface): + '''Entity ifcsurfaceoflinearextrusion definition. + + :param extrudeddirection + :type extrudeddirection:ifcdirection + + :param depth + :type depth:ifclengthmeasure + + :param extrusionaxis + :type extrusionaxis:ifcvector + ''' + def __init__( self , inherited0__sweptcurve , inherited1__position , extrudeddirection,depth, ): + ifcsweptsurface.__init__(self , inherited0__sweptcurve , inherited1__position , ) + self.extrudeddirection = extrudeddirection + self.depth = depth + + @apply + def extrudeddirection(): + def fget( self ): + return self._extrudeddirection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extrudeddirection is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._extrudeddirection = ifcdirection(value) + else: + self._extrudeddirection = value + return property(**locals()) + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._depth = ifclengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def extrusionaxis(): + def fget( self ): + attribute_eval = ((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(self.extrudeddirection,self.depth)) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument extrusionaxis is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def depthgreaterzero(self): + eval_depthgreaterzero_wr = (self.depth > 0) + if not eval_depthgreaterzero_wr: + raise AssertionError('Rule depthgreaterzero violated') + else: + return eval_depthgreaterzero_wr + + +#################### + # ENTITY ifccolumntype # +#################### +class ifccolumntype(ifcbuildingelementtype): + '''Entity ifccolumntype definition. + + :param predefinedtype + :type predefinedtype:ifccolumntypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccolumntypeenum): + self._predefinedtype = ifccolumntypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccolumntypeenum.self.userdefined) or ((self.predefinedtype == ifccolumntypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcproductrepresentation # +#################### +class ifcproductrepresentation(BaseEntityClass): + '''Entity ifcproductrepresentation definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param representations + :type representations:LIST(1,None,'ifcrepresentation', scope = schema_scope) + ''' + def __init__( self , name,description,representations, ): + self.name = name + self.description = description + self.representations = representations + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def representations(): + def fget( self ): + return self._representations + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representations is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcrepresentation', scope = schema_scope)): + self._representations = LIST(value) + else: + self._representations = value + return property(**locals()) + +#################### + # ENTITY ifcmaterialdefinitionrepresentation # +#################### +class ifcmaterialdefinitionrepresentation(ifcproductrepresentation): + '''Entity ifcmaterialdefinitionrepresentation definition. + + :param representedmaterial + :type representedmaterial:ifcmaterial + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__representations , representedmaterial, ): + ifcproductrepresentation.__init__(self , inherited0__name , inherited1__description , inherited2__representations , ) + self.representedmaterial = representedmaterial + + @apply + def representedmaterial(): + def fget( self ): + return self._representedmaterial + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument representedmaterial is mantatory and can not be set to None') + if not check_type(value,ifcmaterial): + self._representedmaterial = ifcmaterial(value) + else: + self._representedmaterial = value + return property(**locals()) + def onlystyledrepresentations(self): + eval_onlystyledrepresentations_wr = (SIZEOF(None) == 0) + if not eval_onlystyledrepresentations_wr: + raise AssertionError('Rule onlystyledrepresentations violated') + else: + return eval_onlystyledrepresentations_wr + + +#################### + # ENTITY ifcmateriallayersetusage # +#################### +class ifcmateriallayersetusage(ifcmaterialusagedefinition): + '''Entity ifcmateriallayersetusage definition. + + :param forlayerset + :type forlayerset:ifcmateriallayerset + + :param layersetdirection + :type layersetdirection:ifclayersetdirectionenum + + :param directionsense + :type directionsense:ifcdirectionsenseenum + + :param offsetfromreferenceline + :type offsetfromreferenceline:ifclengthmeasure + + :param referenceextent + :type referenceextent:ifcpositivelengthmeasure + ''' + def __init__( self , forlayerset,layersetdirection,directionsense,offsetfromreferenceline,referenceextent, ): + ifcmaterialusagedefinition.__init__(self , ) + self.forlayerset = forlayerset + self.layersetdirection = layersetdirection + self.directionsense = directionsense + self.offsetfromreferenceline = offsetfromreferenceline + self.referenceextent = referenceextent + + @apply + def forlayerset(): + def fget( self ): + return self._forlayerset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument forlayerset is mantatory and can not be set to None') + if not check_type(value,ifcmateriallayerset): + self._forlayerset = ifcmateriallayerset(value) + else: + self._forlayerset = value + return property(**locals()) + + @apply + def layersetdirection(): + def fget( self ): + return self._layersetdirection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layersetdirection is mantatory and can not be set to None') + if not check_type(value,ifclayersetdirectionenum): + self._layersetdirection = ifclayersetdirectionenum(value) + else: + self._layersetdirection = value + return property(**locals()) + + @apply + def directionsense(): + def fget( self ): + return self._directionsense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directionsense is mantatory and can not be set to None') + if not check_type(value,ifcdirectionsenseenum): + self._directionsense = ifcdirectionsenseenum(value) + else: + self._directionsense = value + return property(**locals()) + + @apply + def offsetfromreferenceline(): + def fget( self ): + return self._offsetfromreferenceline + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument offsetfromreferenceline is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._offsetfromreferenceline = ifclengthmeasure(value) + else: + self._offsetfromreferenceline = value + return property(**locals()) + + @apply + def referenceextent(): + def fget( self ): + return self._referenceextent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._referenceextent = ifcpositivelengthmeasure(value) + else: + self._referenceextent = value + else: + self._referenceextent = value + return property(**locals()) + +#################### + # ENTITY ifcshapemodel # +#################### +class ifcshapemodel(ifcrepresentation): + '''Entity ifcshapemodel definition. + + :param ofshapeaspect + :type ofshapeaspect:SET(0,1,'ifcshapeaspect', scope = schema_scope) + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcrepresentation.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + + @apply + def ofshapeaspect(): + def fget( self ): + return self._ofshapeaspect + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ofshapeaspect is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr11(self): + eval_wr11_wr = ((SIZEOF(self.self.ifcrepresentation.self.ofproductrepresentation) == 1) XOR (SIZEOF(self.self.ifcrepresentation.self.representationmap) == 1) XOR (SIZEOF(self.ofshapeaspect) == 1)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcmateriallayerset # +#################### +class ifcmateriallayerset(ifcmaterialdefinition): + '''Entity ifcmateriallayerset definition. + + :param materiallayers + :type materiallayers:LIST(1,None,'ifcmateriallayer', scope = schema_scope) + + :param layersetname + :type layersetname:ifclabel + + :param description + :type description:ifctext + + :param totalthickness + :type totalthickness:ifclengthmeasure + ''' + def __init__( self , materiallayers,layersetname,description, ): + ifcmaterialdefinition.__init__(self , ) + self.materiallayers = materiallayers + self.layersetname = layersetname + self.description = description + + @apply + def materiallayers(): + def fget( self ): + return self._materiallayers + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument materiallayers is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcmateriallayer', scope = schema_scope)): + self._materiallayers = LIST(value) + else: + self._materiallayers = value + return property(**locals()) + + @apply + def layersetname(): + def fget( self ): + return self._layersetname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._layersetname = ifclabel(value) + else: + self._layersetname = value + else: + self._layersetname = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def totalthickness(): + def fget( self ): + attribute_eval = ifcmlstotalthickness(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument totalthickness is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcperformancehistory # +#################### +class ifcperformancehistory(ifccontrol): + '''Entity ifcperformancehistory definition. + + :param lifecyclephase + :type lifecyclephase:ifclabel + + :param predefinedtype + :type predefinedtype:ifcperformancehistorytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , lifecyclephase,predefinedtype, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , ) + self.lifecyclephase = lifecyclephase + self.predefinedtype = predefinedtype + + @apply + def lifecyclephase(): + def fget( self ): + return self._lifecyclephase + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lifecyclephase is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._lifecyclephase = ifclabel(value) + else: + self._lifecyclephase = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcperformancehistorytypeenum): + self._predefinedtype = ifcperformancehistorytypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcductsegmenttype # +#################### +class ifcductsegmenttype(ifcflowsegmenttype): + '''Entity ifcductsegmenttype definition. + + :param predefinedtype + :type predefinedtype:ifcductsegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowsegmenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcductsegmenttypeenum): + self._predefinedtype = ifcductsegmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcductsegmenttypeenum.self.userdefined) or ((self.predefinedtype == ifcductsegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifclagtime # +#################### +class ifclagtime(ifcschedulingtime): + '''Entity ifclagtime definition. + + :param lagvalue + :type lagvalue:ifctimeorratioselect + + :param durationtype + :type durationtype:ifctaskdurationenum + ''' + def __init__( self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , lagvalue,durationtype, ): + ifcschedulingtime.__init__(self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , ) + self.lagvalue = lagvalue + self.durationtype = durationtype + + @apply + def lagvalue(): + def fget( self ): + return self._lagvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lagvalue is mantatory and can not be set to None') + if not check_type(value,ifctimeorratioselect): + self._lagvalue = ifctimeorratioselect(value) + else: + self._lagvalue = value + return property(**locals()) + + @apply + def durationtype(): + def fget( self ): + return self._durationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument durationtype is mantatory and can not be set to None') + if not check_type(value,ifctaskdurationenum): + self._durationtype = ifctaskdurationenum(value) + else: + self._durationtype = value + return property(**locals()) + +#################### + # ENTITY ifcnamedunit # +#################### +class ifcnamedunit(BaseEntityClass): + '''Entity ifcnamedunit definition. + + :param dimensions + :type dimensions:ifcdimensionalexponents + + :param unittype + :type unittype:ifcunitenum + ''' + def __init__( self , dimensions,unittype, ): + self.dimensions = dimensions + self.unittype = unittype + + @apply + def dimensions(): + def fget( self ): + return self._dimensions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dimensions is mantatory and can not be set to None') + if not check_type(value,ifcdimensionalexponents): + self._dimensions = ifcdimensionalexponents(value) + else: + self._dimensions = value + return property(**locals()) + + @apply + def unittype(): + def fget( self ): + return self._unittype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unittype is mantatory and can not be set to None') + if not check_type(value,ifcunitenum): + self._unittype = ifcunitenum(value) + else: + self._unittype = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ifccorrectdimensions(self.self.unittype,self.self.dimensions) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcconversionbasedunit # +#################### +class ifcconversionbasedunit(ifcnamedunit): + '''Entity ifcconversionbasedunit definition. + + :param name + :type name:ifclabel + + :param conversionfactor + :type conversionfactor:ifcmeasurewithunit + + :param hasexternalreference + :type hasexternalreference:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + ''' + def __init__( self , inherited0__dimensions , inherited1__unittype , name,conversionfactor, ): + ifcnamedunit.__init__(self , inherited0__dimensions , inherited1__unittype , ) + self.name = name + self.conversionfactor = conversionfactor + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def conversionfactor(): + def fget( self ): + return self._conversionfactor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument conversionfactor is mantatory and can not be set to None') + if not check_type(value,ifcmeasurewithunit): + self._conversionfactor = ifcmeasurewithunit(value) + else: + self._conversionfactor = value + return property(**locals()) + + @apply + def hasexternalreference(): + def fget( self ): + return self._hasexternalreference + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreference is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcconversionbasedunitwithoffset # +#################### +class ifcconversionbasedunitwithoffset(ifcconversionbasedunit): + '''Entity ifcconversionbasedunitwithoffset definition. + + :param conversionoffset + :type conversionoffset:ifcreal + ''' + def __init__( self , inherited0__dimensions , inherited1__unittype , inherited2__name , inherited3__conversionfactor , conversionoffset, ): + ifcconversionbasedunit.__init__(self , inherited0__dimensions , inherited1__unittype , inherited2__name , inherited3__conversionfactor , ) + self.conversionoffset = conversionoffset + + @apply + def conversionoffset(): + def fget( self ): + return self._conversionoffset + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument conversionoffset is mantatory and can not be set to None') + if not check_type(value,ifcreal): + self._conversionoffset = ifcreal(value) + else: + self._conversionoffset = value + return property(**locals()) + +#################### + # ENTITY ifcdampertype # +#################### +class ifcdampertype(ifcflowcontrollertype): + '''Entity ifcdampertype definition. + + :param predefinedtype + :type predefinedtype:ifcdampertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcdampertypeenum): + self._predefinedtype = ifcdampertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcdampertypeenum.self.userdefined) or ((self.predefinedtype == ifcdampertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcphysicalquantity # +#################### +class ifcphysicalquantity(BaseEntityClass): + '''Entity ifcphysicalquantity definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param hasexternalreferences + :type hasexternalreferences:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + + :param partofcomplex + :type partofcomplex:SET(0,1,'ifcphysicalcomplexquantity', scope = schema_scope) + ''' + def __init__( self , name,description, ): + self.name = name + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def hasexternalreferences(): + def fget( self ): + return self._hasexternalreferences + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreferences is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def partofcomplex(): + def fget( self ): + return self._partofcomplex + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofcomplex is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcphysicalsimplequantity # +#################### +class ifcphysicalsimplequantity(ifcphysicalquantity): + '''Entity ifcphysicalsimplequantity definition. + + :param unit + :type unit:ifcnamedunit + ''' + def __init__( self , inherited0__name , inherited1__description , unit, ): + ifcphysicalquantity.__init__(self , inherited0__name , inherited1__description , ) + self.unit = unit + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnamedunit): + self._unit = ifcnamedunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + +#################### + # ENTITY ifcwindowliningproperties # +#################### +class ifcwindowliningproperties(ifcpredefinedpropertyset): + '''Entity ifcwindowliningproperties definition. + + :param liningdepth + :type liningdepth:ifcpositivelengthmeasure + + :param liningthickness + :type liningthickness:ifcnonnegativelengthmeasure + + :param transomthickness + :type transomthickness:ifcnonnegativelengthmeasure + + :param mullionthickness + :type mullionthickness:ifcnonnegativelengthmeasure + + :param firsttransomoffset + :type firsttransomoffset:ifcnormalisedratiomeasure + + :param secondtransomoffset + :type secondtransomoffset:ifcnormalisedratiomeasure + + :param firstmullionoffset + :type firstmullionoffset:ifcnormalisedratiomeasure + + :param secondmullionoffset + :type secondmullionoffset:ifcnormalisedratiomeasure + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + + :param liningoffset + :type liningoffset:ifclengthmeasure + + :param liningtopaneloffsetx + :type liningtopaneloffsetx:ifclengthmeasure + + :param liningtopaneloffsety + :type liningtopaneloffsety:ifclengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , liningdepth,liningthickness,transomthickness,mullionthickness,firsttransomoffset,secondtransomoffset,firstmullionoffset,secondmullionoffset,shapeaspectstyle,liningoffset,liningtopaneloffsetx,liningtopaneloffsety, ): + ifcpredefinedpropertyset.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.liningdepth = liningdepth + self.liningthickness = liningthickness + self.transomthickness = transomthickness + self.mullionthickness = mullionthickness + self.firsttransomoffset = firsttransomoffset + self.secondtransomoffset = secondtransomoffset + self.firstmullionoffset = firstmullionoffset + self.secondmullionoffset = secondmullionoffset + self.shapeaspectstyle = shapeaspectstyle + self.liningoffset = liningoffset + self.liningtopaneloffsetx = liningtopaneloffsetx + self.liningtopaneloffsety = liningtopaneloffsety + + @apply + def liningdepth(): + def fget( self ): + return self._liningdepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._liningdepth = ifcpositivelengthmeasure(value) + else: + self._liningdepth = value + else: + self._liningdepth = value + return property(**locals()) + + @apply + def liningthickness(): + def fget( self ): + return self._liningthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._liningthickness = ifcnonnegativelengthmeasure(value) + else: + self._liningthickness = value + else: + self._liningthickness = value + return property(**locals()) + + @apply + def transomthickness(): + def fget( self ): + return self._transomthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._transomthickness = ifcnonnegativelengthmeasure(value) + else: + self._transomthickness = value + else: + self._transomthickness = value + return property(**locals()) + + @apply + def mullionthickness(): + def fget( self ): + return self._mullionthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._mullionthickness = ifcnonnegativelengthmeasure(value) + else: + self._mullionthickness = value + else: + self._mullionthickness = value + return property(**locals()) + + @apply + def firsttransomoffset(): + def fget( self ): + return self._firsttransomoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._firsttransomoffset = ifcnormalisedratiomeasure(value) + else: + self._firsttransomoffset = value + else: + self._firsttransomoffset = value + return property(**locals()) + + @apply + def secondtransomoffset(): + def fget( self ): + return self._secondtransomoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._secondtransomoffset = ifcnormalisedratiomeasure(value) + else: + self._secondtransomoffset = value + else: + self._secondtransomoffset = value + return property(**locals()) + + @apply + def firstmullionoffset(): + def fget( self ): + return self._firstmullionoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._firstmullionoffset = ifcnormalisedratiomeasure(value) + else: + self._firstmullionoffset = value + else: + self._firstmullionoffset = value + return property(**locals()) + + @apply + def secondmullionoffset(): + def fget( self ): + return self._secondmullionoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._secondmullionoffset = ifcnormalisedratiomeasure(value) + else: + self._secondmullionoffset = value + else: + self._secondmullionoffset = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + + @apply + def liningoffset(): + def fget( self ): + return self._liningoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._liningoffset = ifclengthmeasure(value) + else: + self._liningoffset = value + else: + self._liningoffset = value + return property(**locals()) + + @apply + def liningtopaneloffsetx(): + def fget( self ): + return self._liningtopaneloffsetx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._liningtopaneloffsetx = ifclengthmeasure(value) + else: + self._liningtopaneloffsetx = value + else: + self._liningtopaneloffsetx = value + return property(**locals()) + + @apply + def liningtopaneloffsety(): + def fget( self ): + return self._liningtopaneloffsety + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._liningtopaneloffsety = ifclengthmeasure(value) + else: + self._liningtopaneloffsety = value + else: + self._liningtopaneloffsety = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = ( not (EXISTS(self.liningdepth) and ( not EXISTS(self.liningthickness)))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = ( not (( not EXISTS(self.firsttransomoffset)) and EXISTS(self.secondtransomoffset))) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + def wr33(self): + eval_wr33_wr = ( not (( not EXISTS(self.firstmullionoffset)) and EXISTS(self.secondmullionoffset))) + if not eval_wr33_wr: + raise AssertionError('Rule wr33 violated') + else: + return eval_wr33_wr + + def wr34(self): + eval_wr34_wr = (EXISTS(self.self.ifcpropertysetdefinition.self.definestype[1]) and (('IFC4.IFCWINDOWTYPE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1])) or ('IFC4.IFCWINDOWSTYLE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1])))) + if not eval_wr34_wr: + raise AssertionError('Rule wr34 violated') + else: + return eval_wr34_wr + + +#################### + # ENTITY ifcwindow # +#################### +class ifcwindow(ifcbuildingelement): + '''Entity ifcwindow definition. + + :param overallheight + :type overallheight:ifcpositivelengthmeasure + + :param overallwidth + :type overallwidth:ifcpositivelengthmeasure + + :param predefinedtype + :type predefinedtype:ifcwindowtypeenum + + :param partitioningtype + :type partitioningtype:ifcwindowtypepartitioningenum + + :param userdefinedpartitioningtype + :type userdefinedpartitioningtype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , overallheight,overallwidth,predefinedtype,partitioningtype,userdefinedpartitioningtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.overallheight = overallheight + self.overallwidth = overallwidth + self.predefinedtype = predefinedtype + self.partitioningtype = partitioningtype + self.userdefinedpartitioningtype = userdefinedpartitioningtype + + @apply + def overallheight(): + def fget( self ): + return self._overallheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._overallheight = ifcpositivelengthmeasure(value) + else: + self._overallheight = value + else: + self._overallheight = value + return property(**locals()) + + @apply + def overallwidth(): + def fget( self ): + return self._overallwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._overallwidth = ifcpositivelengthmeasure(value) + else: + self._overallwidth = value + else: + self._overallwidth = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcwindowtypeenum): + self._predefinedtype = ifcwindowtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def partitioningtype(): + def fget( self ): + return self._partitioningtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcwindowtypepartitioningenum): + self._partitioningtype = ifcwindowtypepartitioningenum(value) + else: + self._partitioningtype = value + else: + self._partitioningtype = value + return property(**locals()) + + @apply + def userdefinedpartitioningtype(): + def fget( self ): + return self._userdefinedpartitioningtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedpartitioningtype = ifclabel(value) + else: + self._userdefinedpartitioningtype = value + else: + self._userdefinedpartitioningtype = value + return property(**locals()) + def correctstyleassigned(self): + eval_correctstyleassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCWINDOWTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correctstyleassigned_wr: + raise AssertionError('Rule correctstyleassigned violated') + else: + return eval_correctstyleassigned_wr + + +#################### + # ENTITY ifcwindowstandardcase # +#################### +class ifcwindowstandardcase(ifcwindow): + '''Entity ifcwindowstandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__overallheight , inherited9__overallwidth , inherited10__predefinedtype , inherited11__partitioningtype , inherited12__userdefinedpartitioningtype , ): + ifcwindow.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__overallheight , inherited9__overallwidth , inherited10__predefinedtype , inherited11__partitioningtype , inherited12__userdefinedpartitioningtype , ) + +#################### + # ENTITY ifcboiler # +#################### +class ifcboiler(ifcenergyconversiondevice): + '''Entity ifcboiler definition. + + :param predefinedtype + :type predefinedtype:ifcboilertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcboilertypeenum): + self._predefinedtype = ifcboilertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcboilertypeenum.self.userdefined)) or ((self.predefinedtype == ifcboilertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCBOILERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcorganization # +#################### +class ifcorganization(BaseEntityClass): + '''Entity ifcorganization definition. + + :param identification + :type identification:ifcidentifier + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param roles + :type roles:LIST(1,None,'ifcactorrole', scope = schema_scope) + + :param addresses + :type addresses:LIST(1,None,'ifcaddress', scope = schema_scope) + + :param isrelatedby + :type isrelatedby:SET(0,None,'ifcorganizationrelationship', scope = schema_scope) + + :param relates + :type relates:SET(0,None,'ifcorganizationrelationship', scope = schema_scope) + + :param engages + :type engages:SET(0,None,'ifcpersonandorganization', scope = schema_scope) + ''' + def __init__( self , identification,name,description,roles,addresses, ): + self.identification = identification + self.name = name + self.description = description + self.roles = roles + self.addresses = addresses + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + else: + self._identification = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def roles(): + def fget( self ): + return self._roles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcactorrole', scope = schema_scope)): + self._roles = LIST(value) + else: + self._roles = value + else: + self._roles = value + return property(**locals()) + + @apply + def addresses(): + def fget( self ): + return self._addresses + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcaddress', scope = schema_scope)): + self._addresses = LIST(value) + else: + self._addresses = value + else: + self._addresses = value + return property(**locals()) + + @apply + def isrelatedby(): + def fget( self ): + return self._isrelatedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isrelatedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def relates(): + def fget( self ): + return self._relates + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument relates is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def engages(): + def fget( self ): + return self._engages + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument engages is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcquantitycount # +#################### +class ifcquantitycount(ifcphysicalsimplequantity): + '''Entity ifcquantitycount definition. + + :param countvalue + :type countvalue:ifccountmeasure + + :param formula + :type formula:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , countvalue,formula, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.countvalue = countvalue + self.formula = formula + + @apply + def countvalue(): + def fget( self ): + return self._countvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument countvalue is mantatory and can not be set to None') + if not check_type(value,ifccountmeasure): + self._countvalue = ifccountmeasure(value) + else: + self._countvalue = value + return property(**locals()) + + @apply + def formula(): + def fget( self ): + return self._formula + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._formula = ifclabel(value) + else: + self._formula = value + else: + self._formula = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (self.countvalue >= 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcspaceheater # +#################### +class ifcspaceheater(ifcflowterminal): + '''Entity ifcspaceheater definition. + + :param predefinedtype + :type predefinedtype:ifcspaceheatertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcspaceheatertypeenum): + self._predefinedtype = ifcspaceheatertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcspaceheatertypeenum.self.userdefined)) or ((self.predefinedtype == ifcspaceheatertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSPACEHEATERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcannotation # +#################### +class ifcannotation(ifcproduct): + '''Entity ifcannotation definition. + + :param containedinstructure + :type containedinstructure:SET(0,1,'ifcrelcontainedinspatialstructure', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + + @apply + def containedinstructure(): + def fget( self ): + return self._containedinstructure + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containedinstructure is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcfacebasedsurfacemodel # +#################### +class ifcfacebasedsurfacemodel(ifcgeometricrepresentationitem): + '''Entity ifcfacebasedsurfacemodel definition. + + :param fbsmfaces + :type fbsmfaces:SET(1,None,'ifcconnectedfaceset', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , fbsmfaces, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.fbsmfaces = fbsmfaces + + @apply + def fbsmfaces(): + def fget( self ): + return self._fbsmfaces + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fbsmfaces is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcconnectedfaceset', scope = schema_scope)): + self._fbsmfaces = SET(value) + else: + self._fbsmfaces = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcpropertyenumeration # +#################### +class ifcpropertyenumeration(ifcpropertyabstraction): + '''Entity ifcpropertyenumeration definition. + + :param name + :type name:ifclabel + + :param enumerationvalues + :type enumerationvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param unit + :type unit:ifcunit + ''' + def __init__( self , name,enumerationvalues,unit, ): + ifcpropertyabstraction.__init__(self , ) + self.name = name + self.enumerationvalues = enumerationvalues + self.unit = unit + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def enumerationvalues(): + def fget( self ): + return self._enumerationvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument enumerationvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._enumerationvalues = LIST(value) + else: + self._enumerationvalues = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + def wr01(self): + eval_wr01_wr = (SIZEOF(None) == 0) + if not eval_wr01_wr: + raise AssertionError('Rule wr01 violated') + else: + return eval_wr01_wr + + +#################### + # ENTITY ifcrelconnectsports # +#################### +class ifcrelconnectsports(ifcrelconnects): + '''Entity ifcrelconnectsports definition. + + :param relatingport + :type relatingport:ifcport + + :param relatedport + :type relatedport:ifcport + + :param realizingelement + :type realizingelement:ifcelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingport,relatedport,realizingelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingport = relatingport + self.relatedport = relatedport + self.realizingelement = realizingelement + + @apply + def relatingport(): + def fget( self ): + return self._relatingport + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingport is mantatory and can not be set to None') + if not check_type(value,ifcport): + self._relatingport = ifcport(value) + else: + self._relatingport = value + return property(**locals()) + + @apply + def relatedport(): + def fget( self ): + return self._relatedport + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedport is mantatory and can not be set to None') + if not check_type(value,ifcport): + self._relatedport = ifcport(value) + else: + self._relatedport = value + return property(**locals()) + + @apply + def realizingelement(): + def fget( self ): + return self._realizingelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelement): + self._realizingelement = ifcelement(value) + else: + self._realizingelement = value + else: + self._realizingelement = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (self.relatingport != self.relatedport) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcdoor # +#################### +class ifcdoor(ifcbuildingelement): + '''Entity ifcdoor definition. + + :param overallheight + :type overallheight:ifcpositivelengthmeasure + + :param overallwidth + :type overallwidth:ifcpositivelengthmeasure + + :param predefinedtype + :type predefinedtype:ifcdoortypeenum + + :param operationtype + :type operationtype:ifcdoortypeoperationenum + + :param userdefinedoperationtype + :type userdefinedoperationtype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , overallheight,overallwidth,predefinedtype,operationtype,userdefinedoperationtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.overallheight = overallheight + self.overallwidth = overallwidth + self.predefinedtype = predefinedtype + self.operationtype = operationtype + self.userdefinedoperationtype = userdefinedoperationtype + + @apply + def overallheight(): + def fget( self ): + return self._overallheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._overallheight = ifcpositivelengthmeasure(value) + else: + self._overallheight = value + else: + self._overallheight = value + return property(**locals()) + + @apply + def overallwidth(): + def fget( self ): + return self._overallwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._overallwidth = ifcpositivelengthmeasure(value) + else: + self._overallwidth = value + else: + self._overallwidth = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdoortypeenum): + self._predefinedtype = ifcdoortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdoortypeoperationenum): + self._operationtype = ifcdoortypeoperationenum(value) + else: + self._operationtype = value + else: + self._operationtype = value + return property(**locals()) + + @apply + def userdefinedoperationtype(): + def fget( self ): + return self._userdefinedoperationtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedoperationtype = ifclabel(value) + else: + self._userdefinedoperationtype = value + else: + self._userdefinedoperationtype = value + return property(**locals()) + def correctstyleassigned(self): + eval_correctstyleassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCDOORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correctstyleassigned_wr: + raise AssertionError('Rule correctstyleassigned violated') + else: + return eval_correctstyleassigned_wr + + +#################### + # ENTITY ifcdoorstandardcase # +#################### +class ifcdoorstandardcase(ifcdoor): + '''Entity ifcdoorstandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__overallheight , inherited9__overallwidth , inherited10__predefinedtype , inherited11__operationtype , inherited12__userdefinedoperationtype , ): + ifcdoor.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__overallheight , inherited9__overallwidth , inherited10__predefinedtype , inherited11__operationtype , inherited12__userdefinedoperationtype , ) + +#################### + # ENTITY ifcrectangulartrimmedsurface # +#################### +class ifcrectangulartrimmedsurface(ifcboundedsurface): + '''Entity ifcrectangulartrimmedsurface definition. + + :param basissurface + :type basissurface:ifcsurface + + :param u1 + :type u1:ifcparametervalue + + :param v1 + :type v1:ifcparametervalue + + :param u2 + :type u2:ifcparametervalue + + :param v2 + :type v2:ifcparametervalue + + :param usense + :type usense:BOOLEAN + + :param vsense + :type vsense:BOOLEAN + ''' + def __init__( self , basissurface,u1,v1,u2,v2,usense,vsense, ): + ifcboundedsurface.__init__(self , ) + self.basissurface = basissurface + self.u1 = u1 + self.v1 = v1 + self.u2 = u2 + self.v2 = v2 + self.usense = usense + self.vsense = vsense + + @apply + def basissurface(): + def fget( self ): + return self._basissurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basissurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._basissurface = ifcsurface(value) + else: + self._basissurface = value + return property(**locals()) + + @apply + def u1(): + def fget( self ): + return self._u1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u1 is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._u1 = ifcparametervalue(value) + else: + self._u1 = value + return property(**locals()) + + @apply + def v1(): + def fget( self ): + return self._v1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v1 is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._v1 = ifcparametervalue(value) + else: + self._v1 = value + return property(**locals()) + + @apply + def u2(): + def fget( self ): + return self._u2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument u2 is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._u2 = ifcparametervalue(value) + else: + self._u2 = value + return property(**locals()) + + @apply + def v2(): + def fget( self ): + return self._v2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument v2 is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._v2 = ifcparametervalue(value) + else: + self._v2 = value + return property(**locals()) + + @apply + def usense(): + def fget( self ): + return self._usense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument usense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._usense = BOOLEAN(value) + else: + self._usense = value + return property(**locals()) + + @apply + def vsense(): + def fget( self ): + return self._vsense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vsense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._vsense = BOOLEAN(value) + else: + self._vsense = value + return property(**locals()) + def u1andu2different(self): + eval_u1andu2different_wr = (self.u1 != self.u2) + if not eval_u1andu2different_wr: + raise AssertionError('Rule u1andu2different violated') + else: + return eval_u1andu2different_wr + + def v1andv2different(self): + eval_v1andv2different_wr = (self.v1 != self.v2) + if not eval_v1andv2different_wr: + raise AssertionError('Rule v1andv2different violated') + else: + return eval_v1andv2different_wr + + def usensecompatible(self): + eval_usensecompatible_wr = (((('IFC4.IFCELEMENTARYSURFACE' == TYPEOF(self.basissurface)) and ( not ('IFC4.IFCPLANE' == TYPEOF(self.basissurface)))) or ('IFC4.IFCSURFACEOFREVOLUTION' == TYPEOF(self.basissurface))) or (self.usense == (self.u2 > self.u1))) + if not eval_usensecompatible_wr: + raise AssertionError('Rule usensecompatible violated') + else: + return eval_usensecompatible_wr + + def vsensecompatible(self): + eval_vsensecompatible_wr = (self.vsense == (self.v2 > self.v1)) + if not eval_vsensecompatible_wr: + raise AssertionError('Rule vsensecompatible violated') + else: + return eval_vsensecompatible_wr + + +#################### + # ENTITY ifcspatialstructureelement # +#################### +class ifcspatialstructureelement(ifcspatialelement): + '''Entity ifcspatialstructureelement definition. + + :param compositiontype + :type compositiontype:ifcelementcompositionenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , compositiontype, ): + ifcspatialelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , ) + self.compositiontype = compositiontype + + @apply + def compositiontype(): + def fget( self ): + return self._compositiontype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelementcompositionenum): + self._compositiontype = ifcelementcompositionenum(value) + else: + self._compositiontype = value + else: + self._compositiontype = value + return property(**locals()) + def wr41(self): + eval_wr41_wr = (((HIINDEX(self.self.ifcobjectdefinition.self.decomposes) == 1) and ('IFC4.IFCRELAGGREGATES' == TYPEOF(self.self.ifcobjectdefinition.self.decomposes[1]))) and (('IFC4.IFCPROJECT' == TYPEOF(self.self.ifcobjectdefinition.self.decomposes[1].self.relatingobject)) or ('IFC4.IFCSPATIALSTRUCTUREELEMENT' == TYPEOF(self.self.ifcobjectdefinition.self.decomposes[1].self.relatingobject)))) + if not eval_wr41_wr: + raise AssertionError('Rule wr41 violated') + else: + return eval_wr41_wr + + +#################### + # ENTITY ifcbuilding # +#################### +class ifcbuilding(ifcspatialstructureelement): + '''Entity ifcbuilding definition. + + :param elevationofrefheight + :type elevationofrefheight:ifclengthmeasure + + :param elevationofterrain + :type elevationofterrain:ifclengthmeasure + + :param buildingaddress + :type buildingaddress:ifcpostaladdress + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , elevationofrefheight,elevationofterrain,buildingaddress, ): + ifcspatialstructureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , ) + self.elevationofrefheight = elevationofrefheight + self.elevationofterrain = elevationofterrain + self.buildingaddress = buildingaddress + + @apply + def elevationofrefheight(): + def fget( self ): + return self._elevationofrefheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._elevationofrefheight = ifclengthmeasure(value) + else: + self._elevationofrefheight = value + else: + self._elevationofrefheight = value + return property(**locals()) + + @apply + def elevationofterrain(): + def fget( self ): + return self._elevationofterrain + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._elevationofterrain = ifclengthmeasure(value) + else: + self._elevationofterrain = value + else: + self._elevationofterrain = value + return property(**locals()) + + @apply + def buildingaddress(): + def fget( self ): + return self._buildingaddress + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpostaladdress): + self._buildingaddress = ifcpostaladdress(value) + else: + self._buildingaddress = value + else: + self._buildingaddress = value + return property(**locals()) + +#################### + # ENTITY ifcpropertytemplatedefinition # +#################### +class ifcpropertytemplatedefinition(ifcpropertydefinition): + '''Entity ifcpropertytemplatedefinition definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcpropertydefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + +#################### + # ENTITY ifcpropertytemplate # +#################### +class ifcpropertytemplate(ifcpropertytemplatedefinition): + '''Entity ifcpropertytemplate definition. + + :param partofcomplextemplate + :type partofcomplextemplate:SET(0,None,'ifccomplexpropertytemplate', scope = schema_scope) + + :param partofpsettemplate + :type partofpsettemplate:SET(0,None,'ifcpropertysettemplate', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcpropertytemplatedefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + + @apply + def partofcomplextemplate(): + def fget( self ): + return self._partofcomplextemplate + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofcomplextemplate is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def partofpsettemplate(): + def fget( self ): + return self._partofpsettemplate + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofpsettemplate is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifccolumn # +#################### +class ifccolumn(ifcbuildingelement): + '''Entity ifccolumn definition. + + :param predefinedtype + :type predefinedtype:ifccolumntypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolumntypeenum): + self._predefinedtype = ifccolumntypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccolumntypeenum.self.userdefined)) or ((self.predefinedtype == ifccolumntypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCOLUMNTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcextrudedareasolid # +#################### +class ifcextrudedareasolid(ifcsweptareasolid): + '''Entity ifcextrudedareasolid definition. + + :param extrudeddirection + :type extrudeddirection:ifcdirection + + :param depth + :type depth:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__sweptarea , inherited1__position , extrudeddirection,depth, ): + ifcsweptareasolid.__init__(self , inherited0__sweptarea , inherited1__position , ) + self.extrudeddirection = extrudeddirection + self.depth = depth + + @apply + def extrudeddirection(): + def fget( self ): + return self._extrudeddirection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extrudeddirection is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._extrudeddirection = ifcdirection(value) + else: + self._extrudeddirection = value + return property(**locals()) + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + def validextrusiondirection(self): + eval_validextrusiondirection_wr = (ifcdotproduct((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,0,1]),self.self.extrudeddirection) != 0) + if not eval_validextrusiondirection_wr: + raise AssertionError('Rule validextrusiondirection violated') + else: + return eval_validextrusiondirection_wr + + +#################### + # ENTITY ifcfurnishingelementtype # +#################### +class ifcfurnishingelementtype(ifcelementtype): + '''Entity ifcfurnishingelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcsystemfurnitureelementtype # +#################### +class ifcsystemfurnitureelementtype(ifcfurnishingelementtype): + '''Entity ifcsystemfurnitureelementtype definition. + + :param predefinedtype + :type predefinedtype:ifcsystemfurnitureelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcfurnishingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsystemfurnitureelementtypeenum): + self._predefinedtype = ifcsystemfurnitureelementtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcsystemfurnitureelementtypeenum.self.userdefined) or ((self.predefinedtype == ifcsystemfurnitureelementtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccsgprimitive3d # +#################### +class ifccsgprimitive3d(ifcgeometricrepresentationitem): + '''Entity ifccsgprimitive3d definition. + + :param position + :type position:ifcaxis2placement3d + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , position, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcrightcircularcylinder # +#################### +class ifcrightcircularcylinder(ifccsgprimitive3d): + '''Entity ifcrightcircularcylinder definition. + + :param height + :type height:ifcpositivelengthmeasure + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , height,radius, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.height = height + self.radius = radius + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._height = ifcpositivelengthmeasure(value) + else: + self._height = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifctextliteralwithextent # +#################### +class ifctextliteralwithextent(ifctextliteral): + '''Entity ifctextliteralwithextent definition. + + :param extent + :type extent:ifcplanarextent + + :param boxalignment + :type boxalignment:ifcboxalignment + ''' + def __init__( self , inherited0__literal , inherited1__placement , inherited2__path , extent,boxalignment, ): + ifctextliteral.__init__(self , inherited0__literal , inherited1__placement , inherited2__path , ) + self.extent = extent + self.boxalignment = boxalignment + + @apply + def extent(): + def fget( self ): + return self._extent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument extent is mantatory and can not be set to None') + if not check_type(value,ifcplanarextent): + self._extent = ifcplanarextent(value) + else: + self._extent = value + return property(**locals()) + + @apply + def boxalignment(): + def fget( self ): + return self._boxalignment + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument boxalignment is mantatory and can not be set to None') + if not check_type(value,ifcboxalignment): + self._boxalignment = ifcboxalignment(value) + else: + self._boxalignment = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = ( not ('IFC4.IFCPLANARBOX' == TYPEOF(self.extent))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcconstraint # +#################### +class ifcconstraint(BaseEntityClass): + '''Entity ifcconstraint definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param constraintgrade + :type constraintgrade:ifcconstraintenum + + :param constraintsource + :type constraintsource:ifclabel + + :param creatingactor + :type creatingactor:ifcactorselect + + :param creationtime + :type creationtime:ifcdatetime + + :param userdefinedgrade + :type userdefinedgrade:ifclabel + + :param hasexternalreferences + :type hasexternalreferences:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + + :param propertiesforconstraint + :type propertiesforconstraint:SET(0,None,'ifcresourceconstraintrelationship', scope = schema_scope) + ''' + def __init__( self , name,description,constraintgrade,constraintsource,creatingactor,creationtime,userdefinedgrade, ): + self.name = name + self.description = description + self.constraintgrade = constraintgrade + self.constraintsource = constraintsource + self.creatingactor = creatingactor + self.creationtime = creationtime + self.userdefinedgrade = userdefinedgrade + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def constraintgrade(): + def fget( self ): + return self._constraintgrade + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constraintgrade is mantatory and can not be set to None') + if not check_type(value,ifcconstraintenum): + self._constraintgrade = ifcconstraintenum(value) + else: + self._constraintgrade = value + return property(**locals()) + + @apply + def constraintsource(): + def fget( self ): + return self._constraintsource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._constraintsource = ifclabel(value) + else: + self._constraintsource = value + else: + self._constraintsource = value + return property(**locals()) + + @apply + def creatingactor(): + def fget( self ): + return self._creatingactor + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._creatingactor = ifcactorselect(value) + else: + self._creatingactor = value + else: + self._creatingactor = value + return property(**locals()) + + @apply + def creationtime(): + def fget( self ): + return self._creationtime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._creationtime = ifcdatetime(value) + else: + self._creationtime = value + else: + self._creationtime = value + return property(**locals()) + + @apply + def userdefinedgrade(): + def fget( self ): + return self._userdefinedgrade + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedgrade = ifclabel(value) + else: + self._userdefinedgrade = value + else: + self._userdefinedgrade = value + return property(**locals()) + + @apply + def hasexternalreferences(): + def fget( self ): + return self._hasexternalreferences + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreferences is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def propertiesforconstraint(): + def fget( self ): + return self._propertiesforconstraint + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument propertiesforconstraint is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr11(self): + eval_wr11_wr = ((self.constraintgrade != ifcconstraintenum.self.userdefined) or ((self.constraintgrade == ifcconstraintenum.self.userdefined) and EXISTS(self.self.ifcconstraint.self.userdefinedgrade))) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcobjective # +#################### +class ifcobjective(ifcconstraint): + '''Entity ifcobjective definition. + + :param benchmarkvalues + :type benchmarkvalues:LIST(1,None,'ifcconstraint', scope = schema_scope) + + :param logicalaggregator + :type logicalaggregator:ifclogicaloperatorenum + + :param objectivequalifier + :type objectivequalifier:ifcobjectiveenum + + :param userdefinedqualifier + :type userdefinedqualifier:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__constraintgrade , inherited3__constraintsource , inherited4__creatingactor , inherited5__creationtime , inherited6__userdefinedgrade , benchmarkvalues,logicalaggregator,objectivequalifier,userdefinedqualifier, ): + ifcconstraint.__init__(self , inherited0__name , inherited1__description , inherited2__constraintgrade , inherited3__constraintsource , inherited4__creatingactor , inherited5__creationtime , inherited6__userdefinedgrade , ) + self.benchmarkvalues = benchmarkvalues + self.logicalaggregator = logicalaggregator + self.objectivequalifier = objectivequalifier + self.userdefinedqualifier = userdefinedqualifier + + @apply + def benchmarkvalues(): + def fget( self ): + return self._benchmarkvalues + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcconstraint', scope = schema_scope)): + self._benchmarkvalues = LIST(value) + else: + self._benchmarkvalues = value + else: + self._benchmarkvalues = value + return property(**locals()) + + @apply + def logicalaggregator(): + def fget( self ): + return self._logicalaggregator + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclogicaloperatorenum): + self._logicalaggregator = ifclogicaloperatorenum(value) + else: + self._logicalaggregator = value + else: + self._logicalaggregator = value + return property(**locals()) + + @apply + def objectivequalifier(): + def fget( self ): + return self._objectivequalifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument objectivequalifier is mantatory and can not be set to None') + if not check_type(value,ifcobjectiveenum): + self._objectivequalifier = ifcobjectiveenum(value) + else: + self._objectivequalifier = value + return property(**locals()) + + @apply + def userdefinedqualifier(): + def fget( self ): + return self._userdefinedqualifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedqualifier = ifclabel(value) + else: + self._userdefinedqualifier = value + else: + self._userdefinedqualifier = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ((self.objectivequalifier != ifcobjectiveenum.self.userdefined) or ((self.objectivequalifier == ifcobjectiveenum.self.userdefined) and EXISTS(self.self.ifcobjective.self.userdefinedqualifier))) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcreinforcingelement # +#################### +class ifcreinforcingelement(ifcelementcomponent): + '''Entity ifcreinforcingelement definition. + + :param steelgrade + :type steelgrade:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , steelgrade, ): + ifcelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.steelgrade = steelgrade + + @apply + def steelgrade(): + def fget( self ): + return self._steelgrade + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._steelgrade = ifclabel(value) + else: + self._steelgrade = value + else: + self._steelgrade = value + return property(**locals()) + +#################### + # ENTITY ifcreinforcingmesh # +#################### +class ifcreinforcingmesh(ifcreinforcingelement): + '''Entity ifcreinforcingmesh definition. + + :param meshlength + :type meshlength:ifcpositivelengthmeasure + + :param meshwidth + :type meshwidth:ifcpositivelengthmeasure + + :param longitudinalbarnominaldiameter + :type longitudinalbarnominaldiameter:ifcpositivelengthmeasure + + :param transversebarnominaldiameter + :type transversebarnominaldiameter:ifcpositivelengthmeasure + + :param longitudinalbarcrosssectionarea + :type longitudinalbarcrosssectionarea:ifcareameasure + + :param transversebarcrosssectionarea + :type transversebarcrosssectionarea:ifcareameasure + + :param longitudinalbarspacing + :type longitudinalbarspacing:ifcpositivelengthmeasure + + :param transversebarspacing + :type transversebarspacing:ifcpositivelengthmeasure + + :param predefinedtype + :type predefinedtype:ifcreinforcingmeshtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , meshlength,meshwidth,longitudinalbarnominaldiameter,transversebarnominaldiameter,longitudinalbarcrosssectionarea,transversebarcrosssectionarea,longitudinalbarspacing,transversebarspacing,predefinedtype, ): + ifcreinforcingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , ) + self.meshlength = meshlength + self.meshwidth = meshwidth + self.longitudinalbarnominaldiameter = longitudinalbarnominaldiameter + self.transversebarnominaldiameter = transversebarnominaldiameter + self.longitudinalbarcrosssectionarea = longitudinalbarcrosssectionarea + self.transversebarcrosssectionarea = transversebarcrosssectionarea + self.longitudinalbarspacing = longitudinalbarspacing + self.transversebarspacing = transversebarspacing + self.predefinedtype = predefinedtype + + @apply + def meshlength(): + def fget( self ): + return self._meshlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._meshlength = ifcpositivelengthmeasure(value) + else: + self._meshlength = value + else: + self._meshlength = value + return property(**locals()) + + @apply + def meshwidth(): + def fget( self ): + return self._meshwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._meshwidth = ifcpositivelengthmeasure(value) + else: + self._meshwidth = value + else: + self._meshwidth = value + return property(**locals()) + + @apply + def longitudinalbarnominaldiameter(): + def fget( self ): + return self._longitudinalbarnominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._longitudinalbarnominaldiameter = ifcpositivelengthmeasure(value) + else: + self._longitudinalbarnominaldiameter = value + else: + self._longitudinalbarnominaldiameter = value + return property(**locals()) + + @apply + def transversebarnominaldiameter(): + def fget( self ): + return self._transversebarnominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._transversebarnominaldiameter = ifcpositivelengthmeasure(value) + else: + self._transversebarnominaldiameter = value + else: + self._transversebarnominaldiameter = value + return property(**locals()) + + @apply + def longitudinalbarcrosssectionarea(): + def fget( self ): + return self._longitudinalbarcrosssectionarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._longitudinalbarcrosssectionarea = ifcareameasure(value) + else: + self._longitudinalbarcrosssectionarea = value + else: + self._longitudinalbarcrosssectionarea = value + return property(**locals()) + + @apply + def transversebarcrosssectionarea(): + def fget( self ): + return self._transversebarcrosssectionarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._transversebarcrosssectionarea = ifcareameasure(value) + else: + self._transversebarcrosssectionarea = value + else: + self._transversebarcrosssectionarea = value + return property(**locals()) + + @apply + def longitudinalbarspacing(): + def fget( self ): + return self._longitudinalbarspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._longitudinalbarspacing = ifcpositivelengthmeasure(value) + else: + self._longitudinalbarspacing = value + else: + self._longitudinalbarspacing = value + return property(**locals()) + + @apply + def transversebarspacing(): + def fget( self ): + return self._transversebarspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._transversebarspacing = ifcpositivelengthmeasure(value) + else: + self._transversebarspacing = value + else: + self._transversebarspacing = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreinforcingmeshtypeenum): + self._predefinedtype = ifcreinforcingmeshtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcreinforcingmeshtypeenum.self.userdefined)) or ((self.predefinedtype == ifcreinforcingmeshtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCREINFORCINGMESHTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifctubebundletype # +#################### +class ifctubebundletype(ifcenergyconversiondevicetype): + '''Entity ifctubebundletype definition. + + :param predefinedtype + :type predefinedtype:ifctubebundletypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctubebundletypeenum): + self._predefinedtype = ifctubebundletypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifctubebundletypeenum.self.userdefined) or ((self.predefinedtype == ifctubebundletypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcdoorliningproperties # +#################### +class ifcdoorliningproperties(ifcpredefinedpropertyset): + '''Entity ifcdoorliningproperties definition. + + :param liningdepth + :type liningdepth:ifcpositivelengthmeasure + + :param liningthickness + :type liningthickness:ifcnonnegativelengthmeasure + + :param thresholddepth + :type thresholddepth:ifcpositivelengthmeasure + + :param thresholdthickness + :type thresholdthickness:ifcnonnegativelengthmeasure + + :param transomthickness + :type transomthickness:ifcnonnegativelengthmeasure + + :param transomoffset + :type transomoffset:ifclengthmeasure + + :param liningoffset + :type liningoffset:ifclengthmeasure + + :param thresholdoffset + :type thresholdoffset:ifclengthmeasure + + :param casingthickness + :type casingthickness:ifcpositivelengthmeasure + + :param casingdepth + :type casingdepth:ifcpositivelengthmeasure + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + + :param liningtopaneloffsetx + :type liningtopaneloffsetx:ifclengthmeasure + + :param liningtopaneloffsety + :type liningtopaneloffsety:ifclengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , liningdepth,liningthickness,thresholddepth,thresholdthickness,transomthickness,transomoffset,liningoffset,thresholdoffset,casingthickness,casingdepth,shapeaspectstyle,liningtopaneloffsetx,liningtopaneloffsety, ): + ifcpredefinedpropertyset.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.liningdepth = liningdepth + self.liningthickness = liningthickness + self.thresholddepth = thresholddepth + self.thresholdthickness = thresholdthickness + self.transomthickness = transomthickness + self.transomoffset = transomoffset + self.liningoffset = liningoffset + self.thresholdoffset = thresholdoffset + self.casingthickness = casingthickness + self.casingdepth = casingdepth + self.shapeaspectstyle = shapeaspectstyle + self.liningtopaneloffsetx = liningtopaneloffsetx + self.liningtopaneloffsety = liningtopaneloffsety + + @apply + def liningdepth(): + def fget( self ): + return self._liningdepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._liningdepth = ifcpositivelengthmeasure(value) + else: + self._liningdepth = value + else: + self._liningdepth = value + return property(**locals()) + + @apply + def liningthickness(): + def fget( self ): + return self._liningthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._liningthickness = ifcnonnegativelengthmeasure(value) + else: + self._liningthickness = value + else: + self._liningthickness = value + return property(**locals()) + + @apply + def thresholddepth(): + def fget( self ): + return self._thresholddepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._thresholddepth = ifcpositivelengthmeasure(value) + else: + self._thresholddepth = value + else: + self._thresholddepth = value + return property(**locals()) + + @apply + def thresholdthickness(): + def fget( self ): + return self._thresholdthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._thresholdthickness = ifcnonnegativelengthmeasure(value) + else: + self._thresholdthickness = value + else: + self._thresholdthickness = value + return property(**locals()) + + @apply + def transomthickness(): + def fget( self ): + return self._transomthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._transomthickness = ifcnonnegativelengthmeasure(value) + else: + self._transomthickness = value + else: + self._transomthickness = value + return property(**locals()) + + @apply + def transomoffset(): + def fget( self ): + return self._transomoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._transomoffset = ifclengthmeasure(value) + else: + self._transomoffset = value + else: + self._transomoffset = value + return property(**locals()) + + @apply + def liningoffset(): + def fget( self ): + return self._liningoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._liningoffset = ifclengthmeasure(value) + else: + self._liningoffset = value + else: + self._liningoffset = value + return property(**locals()) + + @apply + def thresholdoffset(): + def fget( self ): + return self._thresholdoffset + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._thresholdoffset = ifclengthmeasure(value) + else: + self._thresholdoffset = value + else: + self._thresholdoffset = value + return property(**locals()) + + @apply + def casingthickness(): + def fget( self ): + return self._casingthickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._casingthickness = ifcpositivelengthmeasure(value) + else: + self._casingthickness = value + else: + self._casingthickness = value + return property(**locals()) + + @apply + def casingdepth(): + def fget( self ): + return self._casingdepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._casingdepth = ifcpositivelengthmeasure(value) + else: + self._casingdepth = value + else: + self._casingdepth = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + + @apply + def liningtopaneloffsetx(): + def fget( self ): + return self._liningtopaneloffsetx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._liningtopaneloffsetx = ifclengthmeasure(value) + else: + self._liningtopaneloffsetx = value + else: + self._liningtopaneloffsetx = value + return property(**locals()) + + @apply + def liningtopaneloffsety(): + def fget( self ): + return self._liningtopaneloffsety + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._liningtopaneloffsety = ifclengthmeasure(value) + else: + self._liningtopaneloffsety = value + else: + self._liningtopaneloffsety = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = ( not (EXISTS(self.liningdepth) and ( not EXISTS(self.liningthickness)))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = ( not (EXISTS(self.thresholddepth) and ( not EXISTS(self.thresholdthickness)))) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + def wr33(self): + eval_wr33_wr = ((EXISTS(self.transomoffset) and EXISTS(self.transomthickness)) XOR (( not EXISTS(self.transomoffset)) and ( not EXISTS(self.transomthickness)))) + if not eval_wr33_wr: + raise AssertionError('Rule wr33 violated') + else: + return eval_wr33_wr + + def wr34(self): + eval_wr34_wr = ((EXISTS(self.casingdepth) and EXISTS(self.casingthickness)) XOR (( not EXISTS(self.casingdepth)) and ( not EXISTS(self.casingthickness)))) + if not eval_wr34_wr: + raise AssertionError('Rule wr34 violated') + else: + return eval_wr34_wr + + def wr35(self): + eval_wr35_wr = (EXISTS(self.self.ifcpropertysetdefinition.self.definestype[1]) and (('IFC4.IFCDOORTYPE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1])) or ('IFC4.IFCDOORSTYLE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1])))) + if not eval_wr35_wr: + raise AssertionError('Rule wr35 violated') + else: + return eval_wr35_wr + + +#################### + # ENTITY ifcstructuralmember # +#################### +class ifcstructuralmember(ifcstructuralitem): + '''Entity ifcstructuralmember definition. + + :param connectedby + :type connectedby:SET(0,None,'ifcrelconnectsstructuralmember', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ): + ifcstructuralitem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + + @apply + def connectedby(): + def fget( self ): + return self._connectedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcstructuralsurfacemember # +#################### +class ifcstructuralsurfacemember(ifcstructuralmember): + '''Entity ifcstructuralsurfacemember definition. + + :param predefinedtype + :type predefinedtype:ifcstructuralsurfacemembertypeenum + + :param thickness + :type thickness:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , predefinedtype,thickness, ): + ifcstructuralmember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.predefinedtype = predefinedtype + self.thickness = thickness + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstructuralsurfacemembertypeenum): + self._predefinedtype = ifcstructuralsurfacemembertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def thickness(): + def fget( self ): + return self._thickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._thickness = ifcpositivelengthmeasure(value) + else: + self._thickness = value + else: + self._thickness = value + return property(**locals()) + def hasobjecttype(self): + eval_hasobjecttype_wr = ((self.predefinedtype != ifcstructuralsurfacemembertypeenum.self.userdefined) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + +#################### + # ENTITY ifcedgecurve # +#################### +class ifcedgecurve(ifcedge): + '''Entity ifcedgecurve definition. + + :param edgegeometry + :type edgegeometry:ifccurve + + :param samesense + :type samesense:BOOLEAN + ''' + def __init__( self , inherited0__edgestart , inherited1__edgeend , edgegeometry,samesense, ): + ifcedge.__init__(self , inherited0__edgestart , inherited1__edgeend , ) + self.edgegeometry = edgegeometry + self.samesense = samesense + + @apply + def edgegeometry(): + def fget( self ): + return self._edgegeometry + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgegeometry is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._edgegeometry = ifccurve(value) + else: + self._edgegeometry = value + return property(**locals()) + + @apply + def samesense(): + def fget( self ): + return self._samesense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument samesense is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._samesense = BOOLEAN(value) + else: + self._samesense = value + return property(**locals()) + +#################### + # ENTITY ifclightfixturetype # +#################### +class ifclightfixturetype(ifcflowterminaltype): + '''Entity ifclightfixturetype definition. + + :param predefinedtype + :type predefinedtype:ifclightfixturetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifclightfixturetypeenum): + self._predefinedtype = ifclightfixturetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifclightfixturetypeenum.self.userdefined) or ((self.predefinedtype == ifclightfixturetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcline # +#################### +class ifcline(ifccurve): + '''Entity ifcline definition. + + :param pnt + :type pnt:ifccartesianpoint + + :param dir + :type dir:ifcvector + ''' + def __init__( self , pnt,dir, ): + ifccurve.__init__(self , ) + self.pnt = pnt + self.dir = dir + + @apply + def pnt(): + def fget( self ): + return self._pnt + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pnt is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._pnt = ifccartesianpoint(value) + else: + self._pnt = value + return property(**locals()) + + @apply + def dir(): + def fget( self ): + return self._dir + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dir is mantatory and can not be set to None') + if not check_type(value,ifcvector): + self._dir = ifcvector(value) + else: + self._dir = value + return property(**locals()) + def samedim(self): + eval_samedim_wr = (self.dir.self.dim == self.pnt.self.dim) + if not eval_samedim_wr: + raise AssertionError('Rule samedim violated') + else: + return eval_samedim_wr + + +#################### + # ENTITY ifcalarm # +#################### +class ifcalarm(ifcdistributioncontrolelement): + '''Entity ifcalarm definition. + + :param predefinedtype + :type predefinedtype:ifcalarmtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcdistributioncontrolelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcalarmtypeenum): + self._predefinedtype = ifcalarmtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcalarmtypeenum.self.userdefined)) or ((self.predefinedtype == ifcalarmtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCALARMTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcconic # +#################### +class ifcconic(ifccurve): + '''Entity ifcconic definition. + + :param position + :type position:ifcaxis2placement + ''' + def __init__( self , position, ): + ifccurve.__init__(self , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._position = ifcaxis2placement(value) + else: + self._position = value + return property(**locals()) + +#################### + # ENTITY ifcrelconnectsporttoelement # +#################### +class ifcrelconnectsporttoelement(ifcrelconnects): + '''Entity ifcrelconnectsporttoelement definition. + + :param relatingport + :type relatingport:ifcport + + :param relatedelement + :type relatedelement:ifcdistributionelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingport,relatedelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingport = relatingport + self.relatedelement = relatedelement + + @apply + def relatingport(): + def fget( self ): + return self._relatingport + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingport is mantatory and can not be set to None') + if not check_type(value,ifcport): + self._relatingport = ifcport(value) + else: + self._relatingport = value + return property(**locals()) + + @apply + def relatedelement(): + def fget( self ): + return self._relatedelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedelement is mantatory and can not be set to None') + if not check_type(value,ifcdistributionelement): + self._relatedelement = ifcdistributionelement(value) + else: + self._relatedelement = value + return property(**locals()) + +#################### + # ENTITY ifcflowmetertype # +#################### +class ifcflowmetertype(ifcflowcontrollertype): + '''Entity ifcflowmetertype definition. + + :param predefinedtype + :type predefinedtype:ifcflowmetertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcflowmetertypeenum): + self._predefinedtype = ifcflowmetertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcflowmetertypeenum.self.userdefined) or ((self.predefinedtype == ifcflowmetertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcquantityarea # +#################### +class ifcquantityarea(ifcphysicalsimplequantity): + '''Entity ifcquantityarea definition. + + :param areavalue + :type areavalue:ifcareameasure + + :param formula + :type formula:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , areavalue,formula, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.areavalue = areavalue + self.formula = formula + + @apply + def areavalue(): + def fget( self ): + return self._areavalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument areavalue is mantatory and can not be set to None') + if not check_type(value,ifcareameasure): + self._areavalue = ifcareameasure(value) + else: + self._areavalue = value + return property(**locals()) + + @apply + def formula(): + def fget( self ): + return self._formula + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._formula = ifclabel(value) + else: + self._formula = value + else: + self._formula = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.areaunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.areavalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcrelassignstocontrol # +#################### +class ifcrelassignstocontrol(ifcrelassigns): + '''Entity ifcrelassignstocontrol definition. + + :param relatingcontrol + :type relatingcontrol:ifccontrol + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingcontrol, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingcontrol = relatingcontrol + + @apply + def relatingcontrol(): + def fget( self ): + return self._relatingcontrol + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingcontrol is mantatory and can not be set to None') + if not check_type(value,ifccontrol): + self._relatingcontrol = ifccontrol(value) + else: + self._relatingcontrol = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcworkcontrol # +#################### +class ifcworkcontrol(ifccontrol): + '''Entity ifcworkcontrol definition. + + :param creationdate + :type creationdate:ifcdatetime + + :param creators + :type creators:SET(1,None,'ifcperson', scope = schema_scope) + + :param purpose + :type purpose:ifclabel + + :param duration + :type duration:ifcduration + + :param totalfloat + :type totalfloat:ifcduration + + :param starttime + :type starttime:ifcdatetime + + :param finishtime + :type finishtime:ifcdatetime + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , creationdate,creators,purpose,duration,totalfloat,starttime,finishtime, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , ) + self.creationdate = creationdate + self.creators = creators + self.purpose = purpose + self.duration = duration + self.totalfloat = totalfloat + self.starttime = starttime + self.finishtime = finishtime + + @apply + def creationdate(): + def fget( self ): + return self._creationdate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument creationdate is mantatory and can not be set to None') + if not check_type(value,ifcdatetime): + self._creationdate = ifcdatetime(value) + else: + self._creationdate = value + return property(**locals()) + + @apply + def creators(): + def fget( self ): + return self._creators + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcperson', scope = schema_scope)): + self._creators = SET(value) + else: + self._creators = value + else: + self._creators = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._purpose = ifclabel(value) + else: + self._purpose = value + else: + self._purpose = value + return property(**locals()) + + @apply + def duration(): + def fget( self ): + return self._duration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._duration = ifcduration(value) + else: + self._duration = value + else: + self._duration = value + return property(**locals()) + + @apply + def totalfloat(): + def fget( self ): + return self._totalfloat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._totalfloat = ifcduration(value) + else: + self._totalfloat = value + else: + self._totalfloat = value + return property(**locals()) + + @apply + def starttime(): + def fget( self ): + return self._starttime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument starttime is mantatory and can not be set to None') + if not check_type(value,ifcdatetime): + self._starttime = ifcdatetime(value) + else: + self._starttime = value + return property(**locals()) + + @apply + def finishtime(): + def fget( self ): + return self._finishtime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._finishtime = ifcdatetime(value) + else: + self._finishtime = value + else: + self._finishtime = value + return property(**locals()) + +#################### + # ENTITY ifcworkplan # +#################### +class ifcworkplan(ifcworkcontrol): + '''Entity ifcworkplan definition. + + :param predefinedtype + :type predefinedtype:ifcworkplantypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__creationdate , inherited7__creators , inherited8__purpose , inherited9__duration , inherited10__totalfloat , inherited11__starttime , inherited12__finishtime , predefinedtype, ): + ifcworkcontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__creationdate , inherited7__creators , inherited8__purpose , inherited9__duration , inherited10__totalfloat , inherited11__starttime , inherited12__finishtime , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcworkplantypeenum): + self._predefinedtype = ifcworkplantypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcworkplantypeenum.self.userdefined)) or ((self.predefinedtype == ifcworkplantypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpropertydependencyrelationship # +#################### +class ifcpropertydependencyrelationship(ifcresourcelevelrelationship): + '''Entity ifcpropertydependencyrelationship definition. + + :param dependingproperty + :type dependingproperty:ifcproperty + + :param dependantproperty + :type dependantproperty:ifcproperty + + :param expression + :type expression:ifctext + ''' + def __init__( self , inherited0__name , inherited1__description , dependingproperty,dependantproperty,expression, ): + ifcresourcelevelrelationship.__init__(self , inherited0__name , inherited1__description , ) + self.dependingproperty = dependingproperty + self.dependantproperty = dependantproperty + self.expression = expression + + @apply + def dependingproperty(): + def fget( self ): + return self._dependingproperty + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dependingproperty is mantatory and can not be set to None') + if not check_type(value,ifcproperty): + self._dependingproperty = ifcproperty(value) + else: + self._dependingproperty = value + return property(**locals()) + + @apply + def dependantproperty(): + def fget( self ): + return self._dependantproperty + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dependantproperty is mantatory and can not be set to None') + if not check_type(value,ifcproperty): + self._dependantproperty = ifcproperty(value) + else: + self._dependantproperty = value + return property(**locals()) + + @apply + def expression(): + def fget( self ): + return self._expression + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._expression = ifctext(value) + else: + self._expression = value + else: + self._expression = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (self.dependingproperty != self.dependantproperty) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcprotectivedevice # +#################### +class ifcprotectivedevice(ifcflowcontroller): + '''Entity ifcprotectivedevice definition. + + :param predefinedtype + :type predefinedtype:ifcprotectivedevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowcontroller.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcprotectivedevicetypeenum): + self._predefinedtype = ifcprotectivedevicetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcprotectivedevicetypeenum.self.userdefined)) or ((self.predefinedtype == ifcprotectivedevicetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCPROTECTIVEDEVICETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcappliedvalue # +#################### +class ifcappliedvalue(BaseEntityClass): + '''Entity ifcappliedvalue definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param appliedvalue + :type appliedvalue:ifcappliedvalueselect + + :param unitbasis + :type unitbasis:ifcmeasurewithunit + + :param applicabledate + :type applicabledate:ifcdate + + :param fixeduntildate + :type fixeduntildate:ifcdate + + :param category + :type category:ifclabel + + :param condition + :type condition:ifclabel + + :param arithmeticoperator + :type arithmeticoperator:ifcarithmeticoperatorenum + + :param components + :type components:LIST(1,None,'ifcappliedvalue', scope = schema_scope) + + :param hasexternalreference + :type hasexternalreference:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + ''' + def __init__( self , name,description,appliedvalue,unitbasis,applicabledate,fixeduntildate,category,condition,arithmeticoperator,components, ): + self.name = name + self.description = description + self.appliedvalue = appliedvalue + self.unitbasis = unitbasis + self.applicabledate = applicabledate + self.fixeduntildate = fixeduntildate + self.category = category + self.condition = condition + self.arithmeticoperator = arithmeticoperator + self.components = components + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def appliedvalue(): + def fget( self ): + return self._appliedvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcappliedvalueselect): + self._appliedvalue = ifcappliedvalueselect(value) + else: + self._appliedvalue = value + else: + self._appliedvalue = value + return property(**locals()) + + @apply + def unitbasis(): + def fget( self ): + return self._unitbasis + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmeasurewithunit): + self._unitbasis = ifcmeasurewithunit(value) + else: + self._unitbasis = value + else: + self._unitbasis = value + return property(**locals()) + + @apply + def applicabledate(): + def fget( self ): + return self._applicabledate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdate): + self._applicabledate = ifcdate(value) + else: + self._applicabledate = value + else: + self._applicabledate = value + return property(**locals()) + + @apply + def fixeduntildate(): + def fget( self ): + return self._fixeduntildate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdate): + self._fixeduntildate = ifcdate(value) + else: + self._fixeduntildate = value + else: + self._fixeduntildate = value + return property(**locals()) + + @apply + def category(): + def fget( self ): + return self._category + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._category = ifclabel(value) + else: + self._category = value + else: + self._category = value + return property(**locals()) + + @apply + def condition(): + def fget( self ): + return self._condition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._condition = ifclabel(value) + else: + self._condition = value + else: + self._condition = value + return property(**locals()) + + @apply + def arithmeticoperator(): + def fget( self ): + return self._arithmeticoperator + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcarithmeticoperatorenum): + self._arithmeticoperator = ifcarithmeticoperatorenum(value) + else: + self._arithmeticoperator = value + else: + self._arithmeticoperator = value + return property(**locals()) + + @apply + def components(): + def fget( self ): + return self._components + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcappliedvalue', scope = schema_scope)): + self._components = LIST(value) + else: + self._components = value + else: + self._components = value + return property(**locals()) + + @apply + def hasexternalreference(): + def fget( self ): + return self._hasexternalreference + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreference is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcfillareastylehatching # +#################### +class ifcfillareastylehatching(ifcgeometricrepresentationitem): + '''Entity ifcfillareastylehatching definition. + + :param hatchlineappearance + :type hatchlineappearance:ifccurvestyle + + :param startofnexthatchline + :type startofnexthatchline:ifchatchlinedistanceselect + + :param pointofreferencehatchline + :type pointofreferencehatchline:ifccartesianpoint + + :param patternstart + :type patternstart:ifccartesianpoint + + :param hatchlineangle + :type hatchlineangle:ifcplaneanglemeasure + ''' + def __init__( self , hatchlineappearance,startofnexthatchline,pointofreferencehatchline,patternstart,hatchlineangle, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.hatchlineappearance = hatchlineappearance + self.startofnexthatchline = startofnexthatchline + self.pointofreferencehatchline = pointofreferencehatchline + self.patternstart = patternstart + self.hatchlineangle = hatchlineangle + + @apply + def hatchlineappearance(): + def fget( self ): + return self._hatchlineappearance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hatchlineappearance is mantatory and can not be set to None') + if not check_type(value,ifccurvestyle): + self._hatchlineappearance = ifccurvestyle(value) + else: + self._hatchlineappearance = value + return property(**locals()) + + @apply + def startofnexthatchline(): + def fget( self ): + return self._startofnexthatchline + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument startofnexthatchline is mantatory and can not be set to None') + if not check_type(value,ifchatchlinedistanceselect): + self._startofnexthatchline = ifchatchlinedistanceselect(value) + else: + self._startofnexthatchline = value + return property(**locals()) + + @apply + def pointofreferencehatchline(): + def fget( self ): + return self._pointofreferencehatchline + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccartesianpoint): + self._pointofreferencehatchline = ifccartesianpoint(value) + else: + self._pointofreferencehatchline = value + else: + self._pointofreferencehatchline = value + return property(**locals()) + + @apply + def patternstart(): + def fget( self ): + return self._patternstart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccartesianpoint): + self._patternstart = ifccartesianpoint(value) + else: + self._patternstart = value + else: + self._patternstart = value + return property(**locals()) + + @apply + def hatchlineangle(): + def fget( self ): + return self._hatchlineangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hatchlineangle is mantatory and can not be set to None') + if not check_type(value,ifcplaneanglemeasure): + self._hatchlineangle = ifcplaneanglemeasure(value) + else: + self._hatchlineangle = value + return property(**locals()) + def patternstart2d(self): + eval_patternstart2d_wr = (( not EXISTS(self.patternstart)) or (self.patternstart.self.dim == 2)) + if not eval_patternstart2d_wr: + raise AssertionError('Rule patternstart2d violated') + else: + return eval_patternstart2d_wr + + def refhatchline2d(self): + eval_refhatchline2d_wr = (( not EXISTS(self.pointofreferencehatchline)) or (self.pointofreferencehatchline.self.dim == 2)) + if not eval_refhatchline2d_wr: + raise AssertionError('Rule refhatchline2d violated') + else: + return eval_refhatchline2d_wr + + +#################### + # ENTITY ifcheatexchangertype # +#################### +class ifcheatexchangertype(ifcenergyconversiondevicetype): + '''Entity ifcheatexchangertype definition. + + :param predefinedtype + :type predefinedtype:ifcheatexchangertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcheatexchangertypeenum): + self._predefinedtype = ifcheatexchangertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcheatexchangertypeenum.self.userdefined) or ((self.predefinedtype == ifcheatexchangertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcmateriallayer # +#################### +class ifcmateriallayer(ifcmaterialdefinition): + '''Entity ifcmateriallayer definition. + + :param material + :type material:ifcmaterial + + :param layerthickness + :type layerthickness:ifcnonnegativelengthmeasure + + :param isventilated + :type isventilated:ifclogical + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param category + :type category:ifclabel + + :param priority + :type priority:ifcnormalisedratiomeasure + + :param tomateriallayerset + :type tomateriallayerset:ifcmateriallayerset + ''' + def __init__( self , material,layerthickness,isventilated,name,description,category,priority, ): + ifcmaterialdefinition.__init__(self , ) + self.material = material + self.layerthickness = layerthickness + self.isventilated = isventilated + self.name = name + self.description = description + self.category = category + self.priority = priority + + @apply + def material(): + def fget( self ): + return self._material + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmaterial): + self._material = ifcmaterial(value) + else: + self._material = value + else: + self._material = value + return property(**locals()) + + @apply + def layerthickness(): + def fget( self ): + return self._layerthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layerthickness is mantatory and can not be set to None') + if not check_type(value,ifcnonnegativelengthmeasure): + self._layerthickness = ifcnonnegativelengthmeasure(value) + else: + self._layerthickness = value + return property(**locals()) + + @apply + def isventilated(): + def fget( self ): + return self._isventilated + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclogical): + self._isventilated = ifclogical(value) + else: + self._isventilated = value + else: + self._isventilated = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def category(): + def fget( self ): + return self._category + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._category = ifclabel(value) + else: + self._category = value + else: + self._category = value + return property(**locals()) + + @apply + def priority(): + def fget( self ): + return self._priority + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._priority = ifcnormalisedratiomeasure(value) + else: + self._priority = value + else: + self._priority = value + return property(**locals()) + + @apply + def tomateriallayerset(): + def fget( self ): + return self._tomateriallayerset + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument tomateriallayerset is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcmateriallayerwithoffsets # +#################### +class ifcmateriallayerwithoffsets(ifcmateriallayer): + '''Entity ifcmateriallayerwithoffsets definition. + + :param offsetdirection + :type offsetdirection:ifclayersetdirectionenum + + :param offsetvalues + :type offsetvalues:ARRAY(1,2,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__material , inherited1__layerthickness , inherited2__isventilated , inherited3__name , inherited4__description , inherited5__category , inherited6__priority , offsetdirection,offsetvalues, ): + ifcmateriallayer.__init__(self , inherited0__material , inherited1__layerthickness , inherited2__isventilated , inherited3__name , inherited4__description , inherited5__category , inherited6__priority , ) + self.offsetdirection = offsetdirection + self.offsetvalues = offsetvalues + + @apply + def offsetdirection(): + def fget( self ): + return self._offsetdirection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument offsetdirection is mantatory and can not be set to None') + if not check_type(value,ifclayersetdirectionenum): + self._offsetdirection = ifclayersetdirectionenum(value) + else: + self._offsetdirection = value + return property(**locals()) + + @apply + def offsetvalues(): + def fget( self ): + return self._offsetvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument offsetvalues is mantatory and can not be set to None') + if not check_type(value,ARRAY(1,2,'REAL', scope = schema_scope)): + self._offsetvalues = ARRAY(value) + else: + self._offsetvalues = value + return property(**locals()) + +#################### + # ENTITY ifcextendedproperties # +#################### +class ifcextendedproperties(ifcpropertyabstraction): + '''Entity ifcextendedproperties definition. + + :param name + :type name:ifcidentifier + + :param description + :type description:ifctext + + :param properties + :type properties:SET(1,None,'ifcproperty', scope = schema_scope) + ''' + def __init__( self , name,description,properties, ): + ifcpropertyabstraction.__init__(self , ) + self.name = name + self.description = description + self.properties = properties + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._name = ifcidentifier(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def properties(): + def fget( self ): + return self._properties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument properties is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproperty', scope = schema_scope)): + self._properties = SET(value) + else: + self._properties = value + return property(**locals()) + +#################### + # ENTITY ifcmaterialproperties # +#################### +class ifcmaterialproperties(ifcextendedproperties): + '''Entity ifcmaterialproperties definition. + + :param material + :type material:ifcmaterialdefinition + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__properties , material, ): + ifcextendedproperties.__init__(self , inherited0__name , inherited1__description , inherited2__properties , ) + self.material = material + + @apply + def material(): + def fget( self ): + return self._material + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument material is mantatory and can not be set to None') + if not check_type(value,ifcmaterialdefinition): + self._material = ifcmaterialdefinition(value) + else: + self._material = value + return property(**locals()) + +#################### + # ENTITY ifcpolygonalboundedhalfspace # +#################### +class ifcpolygonalboundedhalfspace(ifchalfspacesolid): + '''Entity ifcpolygonalboundedhalfspace definition. + + :param position + :type position:ifcaxis2placement3d + + :param polygonalboundary + :type polygonalboundary:ifcboundedcurve + ''' + def __init__( self , inherited0__basesurface , inherited1__agreementflag , position,polygonalboundary, ): + ifchalfspacesolid.__init__(self , inherited0__basesurface , inherited1__agreementflag , ) + self.position = position + self.polygonalboundary = polygonalboundary + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def polygonalboundary(): + def fget( self ): + return self._polygonalboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument polygonalboundary is mantatory and can not be set to None') + if not check_type(value,ifcboundedcurve): + self._polygonalboundary = ifcboundedcurve(value) + else: + self._polygonalboundary = value + return property(**locals()) + def boundarydim(self): + eval_boundarydim_wr = (self.polygonalboundary.self.dim == 2) + if not eval_boundarydim_wr: + raise AssertionError('Rule boundarydim violated') + else: + return eval_boundarydim_wr + + def boundarytype(self): + eval_boundarytype_wr = (SIZEOF(TYPEOF(self.polygonalboundary) * ['IFC4.IFCPOLYLINE','IFC4.IFCCOMPOSITECURVE']) == 1) + if not eval_boundarytype_wr: + raise AssertionError('Rule boundarytype violated') + else: + return eval_boundarytype_wr + + +#################### + # ENTITY ifcshadingdevicetype # +#################### +class ifcshadingdevicetype(ifcbuildingelementtype): + '''Entity ifcshadingdevicetype definition. + + :param predefinedtype + :type predefinedtype:ifcshadingdevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcshadingdevicetypeenum): + self._predefinedtype = ifcshadingdevicetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcshadingdevicetypeenum.self.userdefined) or ((self.predefinedtype == ifcshadingdevicetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccommunicationsappliance # +#################### +class ifccommunicationsappliance(ifcflowterminal): + '''Entity ifccommunicationsappliance definition. + + :param predefinedtype + :type predefinedtype:ifccommunicationsappliancetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccommunicationsappliancetypeenum): + self._predefinedtype = ifccommunicationsappliancetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccommunicationsappliancetypeenum.self.userdefined)) or ((self.predefinedtype == ifccommunicationsappliancetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCOMMUNICATIONSAPPLIANCETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcflowmovingdevice # +#################### +class ifcflowmovingdevice(ifcdistributionflowelement): + '''Entity ifcflowmovingdevice definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifccompressor # +#################### +class ifccompressor(ifcflowmovingdevice): + '''Entity ifccompressor definition. + + :param predefinedtype + :type predefinedtype:ifccompressortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowmovingdevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccompressortypeenum): + self._predefinedtype = ifccompressortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccompressortypeenum.self.userdefined)) or ((self.predefinedtype == ifccompressortypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCOMPRESSORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifccondensertype # +#################### +class ifccondensertype(ifcenergyconversiondevicetype): + '''Entity ifccondensertype definition. + + :param predefinedtype + :type predefinedtype:ifccondensertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccondensertypeenum): + self._predefinedtype = ifccondensertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccondensertypeenum.self.userdefined) or ((self.predefinedtype == ifccondensertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcheatexchanger # +#################### +class ifcheatexchanger(ifcenergyconversiondevice): + '''Entity ifcheatexchanger definition. + + :param predefinedtype + :type predefinedtype:ifcheatexchangertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcheatexchangertypeenum): + self._predefinedtype = ifcheatexchangertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcheatexchangertypeenum.self.userdefined)) or ((self.predefinedtype == ifcheatexchangertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCHEATEXCHANGERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcslab # +#################### +class ifcslab(ifcbuildingelement): + '''Entity ifcslab definition. + + :param predefinedtype + :type predefinedtype:ifcslabtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcslabtypeenum): + self._predefinedtype = ifcslabtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcslabtypeenum.self.userdefined)) or ((self.predefinedtype == ifcslabtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSLABTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcconstructionmaterialresourcetype # +#################### +class ifcconstructionmaterialresourcetype(ifcconstructionresourcetype): + '''Entity ifcconstructionmaterialresourcetype definition. + + :param predefinedtype + :type predefinedtype:ifcconstructionmaterialresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , predefinedtype, ): + ifcconstructionresourcetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcconstructionmaterialresourcetypeenum): + self._predefinedtype = ifcconstructionmaterialresourcetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcconstructionmaterialresourcetypeenum.self.userdefined) or ((self.predefinedtype == ifcconstructionmaterialresourcetypeenum.self.userdefined) and EXISTS(self.self.ifctyperesource.self.resourcetype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccoolingtowertype # +#################### +class ifccoolingtowertype(ifcenergyconversiondevicetype): + '''Entity ifccoolingtowertype definition. + + :param predefinedtype + :type predefinedtype:ifccoolingtowertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccoolingtowertypeenum): + self._predefinedtype = ifccoolingtowertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccoolingtowertypeenum.self.userdefined) or ((self.predefinedtype == ifccoolingtowertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcclassification # +#################### +class ifcclassification(ifcexternalinformation): + '''Entity ifcclassification definition. + + :param source + :type source:ifclabel + + :param edition + :type edition:ifclabel + + :param editiondate + :type editiondate:ifcdate + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param location + :type location:ifcurireference + + :param referencetokens + :type referencetokens:LIST(1,None,'STRING', scope = schema_scope) + + :param classificationforobjects + :type classificationforobjects:SET(0,None,'ifcrelassociatesclassification', scope = schema_scope) + + :param hasreferences + :type hasreferences:SET(0,None,'ifcclassificationreference', scope = schema_scope) + ''' + def __init__( self , source,edition,editiondate,name,description,location,referencetokens, ): + ifcexternalinformation.__init__(self , ) + self.source = source + self.edition = edition + self.editiondate = editiondate + self.name = name + self.description = description + self.location = location + self.referencetokens = referencetokens + + @apply + def source(): + def fget( self ): + return self._source + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._source = ifclabel(value) + else: + self._source = value + else: + self._source = value + return property(**locals()) + + @apply + def edition(): + def fget( self ): + return self._edition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._edition = ifclabel(value) + else: + self._edition = value + else: + self._edition = value + return property(**locals()) + + @apply + def editiondate(): + def fget( self ): + return self._editiondate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdate): + self._editiondate = ifcdate(value) + else: + self._editiondate = value + else: + self._editiondate = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def location(): + def fget( self ): + return self._location + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcurireference): + self._location = ifcurireference(value) + else: + self._location = value + else: + self._location = value + return property(**locals()) + + @apply + def referencetokens(): + def fget( self ): + return self._referencetokens + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._referencetokens = LIST(value) + else: + self._referencetokens = value + else: + self._referencetokens = value + return property(**locals()) + + @apply + def classificationforobjects(): + def fget( self ): + return self._classificationforobjects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument classificationforobjects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasreferences(): + def fget( self ): + return self._hasreferences + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasreferences is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcresourceconstraintrelationship # +#################### +class ifcresourceconstraintrelationship(ifcresourcelevelrelationship): + '''Entity ifcresourceconstraintrelationship definition. + + :param relatingconstraint + :type relatingconstraint:ifcconstraint + + :param relatedresourceobjects + :type relatedresourceobjects:SET(1,None,'ifcresourceobjectselect', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , relatingconstraint,relatedresourceobjects, ): + ifcresourcelevelrelationship.__init__(self , inherited0__name , inherited1__description , ) + self.relatingconstraint = relatingconstraint + self.relatedresourceobjects = relatedresourceobjects + + @apply + def relatingconstraint(): + def fget( self ): + return self._relatingconstraint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingconstraint is mantatory and can not be set to None') + if not check_type(value,ifcconstraint): + self._relatingconstraint = ifcconstraint(value) + else: + self._relatingconstraint = value + return property(**locals()) + + @apply + def relatedresourceobjects(): + def fget( self ): + return self._relatedresourceobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedresourceobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcresourceobjectselect', scope = schema_scope)): + self._relatedresourceobjects = SET(value) + else: + self._relatedresourceobjects = value + return property(**locals()) + +#################### + # ENTITY ifcfootingtype # +#################### +class ifcfootingtype(ifcbuildingelementtype): + '''Entity ifcfootingtype definition. + + :param predefinedtype + :type predefinedtype:ifcfootingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcfootingtypeenum): + self._predefinedtype = ifcfootingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcfootingtypeenum.self.userdefined) or ((self.predefinedtype == ifcfootingtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcgridaxis # +#################### +class ifcgridaxis(BaseEntityClass): + '''Entity ifcgridaxis definition. + + :param axistag + :type axistag:ifclabel + + :param axiscurve + :type axiscurve:ifccurve + + :param samesense + :type samesense:ifcboolean + + :param partofw + :type partofw:SET(0,1,'ifcgrid', scope = schema_scope) + + :param partofv + :type partofv:SET(0,1,'ifcgrid', scope = schema_scope) + + :param partofu + :type partofu:SET(0,1,'ifcgrid', scope = schema_scope) + + :param hasintersections + :type hasintersections:SET(0,None,'ifcvirtualgridintersection', scope = schema_scope) + ''' + def __init__( self , axistag,axiscurve,samesense, ): + self.axistag = axistag + self.axiscurve = axiscurve + self.samesense = samesense + + @apply + def axistag(): + def fget( self ): + return self._axistag + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._axistag = ifclabel(value) + else: + self._axistag = value + else: + self._axistag = value + return property(**locals()) + + @apply + def axiscurve(): + def fget( self ): + return self._axiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._axiscurve = ifccurve(value) + else: + self._axiscurve = value + return property(**locals()) + + @apply + def samesense(): + def fget( self ): + return self._samesense + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument samesense is mantatory and can not be set to None') + if not check_type(value,ifcboolean): + self._samesense = ifcboolean(value) + else: + self._samesense = value + return property(**locals()) + + @apply + def partofw(): + def fget( self ): + return self._partofw + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofw is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def partofv(): + def fget( self ): + return self._partofv + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofv is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def partofu(): + def fget( self ): + return self._partofu + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument partofu is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasintersections(): + def fget( self ): + return self._hasintersections + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasintersections is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.axiscurve.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((SIZEOF(self.partofu) == 1) XOR (SIZEOF(self.partofv) == 1) XOR (SIZEOF(self.partofw) == 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifccablesegment # +#################### +class ifccablesegment(ifcflowsegment): + '''Entity ifccablesegment definition. + + :param predefinedtype + :type predefinedtype:ifccablesegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowsegment.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccablesegmenttypeenum): + self._predefinedtype = ifccablesegmenttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccablesegmenttypeenum.self.userdefined)) or ((self.predefinedtype == ifccablesegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCABLESEGMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcrelassignstogroupbyfactor # +#################### +class ifcrelassignstogroupbyfactor(ifcrelassignstogroup): + '''Entity ifcrelassignstogroupbyfactor definition. + + :param factor + :type factor:ifcratiomeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatinggroup , factor, ): + ifcrelassignstogroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , inherited6__relatinggroup , ) + self.factor = factor + + @apply + def factor(): + def fget( self ): + return self._factor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument factor is mantatory and can not be set to None') + if not check_type(value,ifcratiomeasure): + self._factor = ifcratiomeasure(value) + else: + self._factor = value + return property(**locals()) + +#################### + # ENTITY ifctransportelement # +#################### +class ifctransportelement(ifcelement): + '''Entity ifctransportelement definition. + + :param predefinedtype + :type predefinedtype:ifctransportelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctransportelementtypeenum): + self._predefinedtype = ifctransportelementtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifctransportelementtypeenum.self.userdefined)) or ((self.predefinedtype == ifctransportelementtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCTRANSPORTELEMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcderivedunit # +#################### +class ifcderivedunit(BaseEntityClass): + '''Entity ifcderivedunit definition. + + :param elements + :type elements:SET(1,None,'ifcderivedunitelement', scope = schema_scope) + + :param unittype + :type unittype:ifcderivedunitenum + + :param userdefinedtype + :type userdefinedtype:ifclabel + + :param dimensions + :type dimensions:ifcdimensionalexponents + ''' + def __init__( self , elements,unittype,userdefinedtype, ): + self.elements = elements + self.unittype = unittype + self.userdefinedtype = userdefinedtype + + @apply + def elements(): + def fget( self ): + return self._elements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument elements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcderivedunitelement', scope = schema_scope)): + self._elements = SET(value) + else: + self._elements = value + return property(**locals()) + + @apply + def unittype(): + def fget( self ): + return self._unittype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unittype is mantatory and can not be set to None') + if not check_type(value,ifcderivedunitenum): + self._unittype = ifcderivedunitenum(value) + else: + self._unittype = value + return property(**locals()) + + @apply + def userdefinedtype(): + def fget( self ): + return self._userdefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedtype = ifclabel(value) + else: + self._userdefinedtype = value + else: + self._userdefinedtype = value + return property(**locals()) + + @apply + def dimensions(): + def fget( self ): + attribute_eval = ifcderivedimensionalexponents(self.elements) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dimensions is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((SIZEOF(self.elements) > 1) or ((SIZEOF(self.elements) == 1) and (self.elements[1].self.exponent != 1))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((self.unittype != ifcderivedunitenum.self.userdefined) or ((self.unittype == ifcderivedunitenum.self.userdefined) and EXISTS(self.self.userdefinedtype))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcbsplinesurface # +#################### +class ifcbsplinesurface(ifcboundedsurface): + '''Entity ifcbsplinesurface definition. + + :param udegree + :type udegree:INTEGER + + :param vdegree + :type vdegree:INTEGER + + :param controlpointslist + :type controlpointslist:LIST(2,None,LIST(2,None,'ifccartesianpoint', scope = schema_scope)) + + :param surfaceform + :type surfaceform:ifcbsplinesurfaceform + + :param uclosed + :type uclosed:LOGICAL + + :param vclosed + :type vclosed:LOGICAL + + :param selfintersect + :type selfintersect:LOGICAL + + :param uupper + :type uupper:INTEGER + + :param vupper + :type vupper:INTEGER + + :param controlpoints + :type controlpoints:ARRAY(0,uupper,ARRAY(0,vupper,'ifccartesianpoint', scope = schema_scope)) + ''' + def __init__( self , udegree,vdegree,controlpointslist,surfaceform,uclosed,vclosed,selfintersect, ): + ifcboundedsurface.__init__(self , ) + self.udegree = udegree + self.vdegree = vdegree + self.controlpointslist = controlpointslist + self.surfaceform = surfaceform + self.uclosed = uclosed + self.vclosed = vclosed + self.selfintersect = selfintersect + + @apply + def udegree(): + def fget( self ): + return self._udegree + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument udegree is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._udegree = INTEGER(value) + else: + self._udegree = value + return property(**locals()) + + @apply + def vdegree(): + def fget( self ): + return self._vdegree + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vdegree is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._vdegree = INTEGER(value) + else: + self._vdegree = value + return property(**locals()) + + @apply + def controlpointslist(): + def fget( self ): + return self._controlpointslist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument controlpointslist is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,LIST(2,None,'ifccartesianpoint', scope = schema_scope))): + self._controlpointslist = LIST(value) + else: + self._controlpointslist = value + return property(**locals()) + + @apply + def surfaceform(): + def fget( self ): + return self._surfaceform + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument surfaceform is mantatory and can not be set to None') + if not check_type(value,ifcbsplinesurfaceform): + self._surfaceform = ifcbsplinesurfaceform(value) + else: + self._surfaceform = value + return property(**locals()) + + @apply + def uclosed(): + def fget( self ): + return self._uclosed + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument uclosed is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._uclosed = LOGICAL(value) + else: + self._uclosed = value + return property(**locals()) + + @apply + def vclosed(): + def fget( self ): + return self._vclosed + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vclosed is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._vclosed = LOGICAL(value) + else: + self._vclosed = value + return property(**locals()) + + @apply + def selfintersect(): + def fget( self ): + return self._selfintersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument selfintersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._selfintersect = LOGICAL(value) + else: + self._selfintersect = value + return property(**locals()) + + @apply + def uupper(): + def fget( self ): + attribute_eval = (SIZEOF(self.controlpointslist) - 1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument uupper is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def vupper(): + def fget( self ): + attribute_eval = (SIZEOF(self.controlpointslist[1]) - 1) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument vupper is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def controlpoints(): + def fget( self ): + attribute_eval = ifcmakearrayofarray(self.controlpointslist,0,self.uupper,0,self.vupper) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument controlpoints is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifccontrollertype # +#################### +class ifccontrollertype(ifcdistributioncontrolelementtype): + '''Entity ifccontrollertype definition. + + :param predefinedtype + :type predefinedtype:ifccontrollertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccontrollertypeenum): + self._predefinedtype = ifccontrollertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccontrollertypeenum.self.userdefined) or ((self.predefinedtype == ifccontrollertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcrelassignstoproduct # +#################### +class ifcrelassignstoproduct(ifcrelassigns): + '''Entity ifcrelassignstoproduct definition. + + :param relatingproduct + :type relatingproduct:ifcproductselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingproduct, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingproduct = relatingproduct + + @apply + def relatingproduct(): + def fget( self ): + return self._relatingproduct + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingproduct is mantatory and can not be set to None') + if not check_type(value,ifcproductselect): + self._relatingproduct = ifcproductselect(value) + else: + self._relatingproduct = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcrepresentationcontext # +#################### +class ifcrepresentationcontext(BaseEntityClass): + '''Entity ifcrepresentationcontext definition. + + :param contextidentifier + :type contextidentifier:ifclabel + + :param contexttype + :type contexttype:ifclabel + + :param representationsincontext + :type representationsincontext:SET(0,None,'ifcrepresentation', scope = schema_scope) + ''' + def __init__( self , contextidentifier,contexttype, ): + self.contextidentifier = contextidentifier + self.contexttype = contexttype + + @apply + def contextidentifier(): + def fget( self ): + return self._contextidentifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._contextidentifier = ifclabel(value) + else: + self._contextidentifier = value + else: + self._contextidentifier = value + return property(**locals()) + + @apply + def contexttype(): + def fget( self ): + return self._contexttype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._contexttype = ifclabel(value) + else: + self._contexttype = value + else: + self._contexttype = value + return property(**locals()) + + @apply + def representationsincontext(): + def fget( self ): + return self._representationsincontext + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument representationsincontext is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcgeometricrepresentationcontext # +#################### +class ifcgeometricrepresentationcontext(ifcrepresentationcontext): + '''Entity ifcgeometricrepresentationcontext definition. + + :param coordinatespacedimension + :type coordinatespacedimension:ifcdimensioncount + + :param precision + :type precision:REAL + + :param worldcoordinatesystem + :type worldcoordinatesystem:ifcaxis2placement + + :param truenorth + :type truenorth:ifcdirection + + :param hassubcontexts + :type hassubcontexts:SET(0,None,'ifcgeometricrepresentationsubcontext', scope = schema_scope) + ''' + def __init__( self , inherited0__contextidentifier , inherited1__contexttype , coordinatespacedimension,precision,worldcoordinatesystem,truenorth, ): + ifcrepresentationcontext.__init__(self , inherited0__contextidentifier , inherited1__contexttype , ) + self.coordinatespacedimension = coordinatespacedimension + self.precision = precision + self.worldcoordinatesystem = worldcoordinatesystem + self.truenorth = truenorth + + @apply + def coordinatespacedimension(): + def fget( self ): + return self._coordinatespacedimension + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordinatespacedimension is mantatory and can not be set to None') + if not check_type(value,ifcdimensioncount): + self._coordinatespacedimension = ifcdimensioncount(value) + else: + self._coordinatespacedimension = value + return property(**locals()) + + @apply + def precision(): + def fget( self ): + return self._precision + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._precision = REAL(value) + else: + self._precision = value + else: + self._precision = value + return property(**locals()) + + @apply + def worldcoordinatesystem(): + def fget( self ): + return self._worldcoordinatesystem + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument worldcoordinatesystem is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._worldcoordinatesystem = ifcaxis2placement(value) + else: + self._worldcoordinatesystem = value + return property(**locals()) + + @apply + def truenorth(): + def fget( self ): + return self._truenorth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._truenorth = ifcdirection(value) + else: + self._truenorth = value + else: + self._truenorth = value + return property(**locals()) + + @apply + def hassubcontexts(): + def fget( self ): + return self._hassubcontexts + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hassubcontexts is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr11(self): + eval_wr11_wr = (( not EXISTS(self.truenorth)) or (HIINDEX(self.truenorth.self.directionratios) == 2)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcstairflight # +#################### +class ifcstairflight(ifcbuildingelement): + '''Entity ifcstairflight definition. + + :param numberofriser + :type numberofriser:INTEGER + + :param numberoftreads + :type numberoftreads:INTEGER + + :param riserheight + :type riserheight:ifcpositivelengthmeasure + + :param treadlength + :type treadlength:ifcpositivelengthmeasure + + :param predefinedtype + :type predefinedtype:ifcstairflighttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , numberofriser,numberoftreads,riserheight,treadlength,predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.numberofriser = numberofriser + self.numberoftreads = numberoftreads + self.riserheight = riserheight + self.treadlength = treadlength + self.predefinedtype = predefinedtype + + @apply + def numberofriser(): + def fget( self ): + return self._numberofriser + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,INTEGER): + self._numberofriser = INTEGER(value) + else: + self._numberofriser = value + else: + self._numberofriser = value + return property(**locals()) + + @apply + def numberoftreads(): + def fget( self ): + return self._numberoftreads + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,INTEGER): + self._numberoftreads = INTEGER(value) + else: + self._numberoftreads = value + else: + self._numberoftreads = value + return property(**locals()) + + @apply + def riserheight(): + def fget( self ): + return self._riserheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._riserheight = ifcpositivelengthmeasure(value) + else: + self._riserheight = value + else: + self._riserheight = value + return property(**locals()) + + @apply + def treadlength(): + def fget( self ): + return self._treadlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._treadlength = ifcpositivelengthmeasure(value) + else: + self._treadlength = value + else: + self._treadlength = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstairflighttypeenum): + self._predefinedtype = ifcstairflighttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcstairflighttypeenum.self.userdefined)) or ((self.predefinedtype == ifcstairflighttypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSTAIRFLIGHTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcpath # +#################### +class ifcpath(ifctopologicalrepresentationitem): + '''Entity ifcpath definition. + + :param edgelist + :type edgelist:LIST(1,None,'ifcorientededge', scope = schema_scope) + ''' + def __init__( self , edgelist, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.edgelist = edgelist + + @apply + def edgelist(): + def fget( self ): + return self._edgelist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgelist is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcorientededge', scope = schema_scope)): + self._edgelist = LIST(value) + else: + self._edgelist = value + return property(**locals()) + def iscontinuous(self): + eval_iscontinuous_wr = ifcpathheadtotail(self) + if not eval_iscontinuous_wr: + raise AssertionError('Rule iscontinuous violated') + else: + return eval_iscontinuous_wr + + +#################### + # ENTITY ifcstair # +#################### +class ifcstair(ifcbuildingelement): + '''Entity ifcstair definition. + + :param predefinedtype + :type predefinedtype:ifcstairtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstairtypeenum): + self._predefinedtype = ifcstairtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctshapedecomposition(self): + eval_correctshapedecomposition_wr = ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 0) or ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 1) and (( not EXISTS(self.self.ifcproduct.self.representation)) or (EXISTS(self.self.ifcproduct.self.representation) and (SIZEOF(None) == 0))))) + if not eval_correctshapedecomposition_wr: + raise AssertionError('Rule correctshapedecomposition violated') + else: + return eval_correctshapedecomposition_wr + + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcstairtypeenum.self.userdefined)) or ((self.predefinedtype == ifcstairtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSTAIRTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcstructuralsurfacereaction # +#################### +class ifcstructuralsurfacereaction(ifcstructuralreaction): + '''Entity ifcstructuralsurfacereaction definition. + + :param predefinedtype + :type predefinedtype:ifcstructuralsurfaceactivitytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , predefinedtype, ): + ifcstructuralreaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstructuralsurfaceactivitytypeenum): + self._predefinedtype = ifcstructuralsurfaceactivitytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def haspredefinedtype(self): + eval_haspredefinedtype_wr = ((self.predefinedtype != ifcstructuralsurfaceactivitytypeenum.self.userdefined) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_haspredefinedtype_wr: + raise AssertionError('Rule haspredefinedtype violated') + else: + return eval_haspredefinedtype_wr + + +#################### + # ENTITY ifcductfitting # +#################### +class ifcductfitting(ifcflowfitting): + '''Entity ifcductfitting definition. + + :param predefinedtype + :type predefinedtype:ifcductfittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowfitting.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcductfittingtypeenum): + self._predefinedtype = ifcductfittingtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcductfittingtypeenum.self.userdefined)) or ((self.predefinedtype == ifcductfittingtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCDUCTFITTINGTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcactorrole # +#################### +class ifcactorrole(BaseEntityClass): + '''Entity ifcactorrole definition. + + :param role + :type role:ifcroleenum + + :param userdefinedrole + :type userdefinedrole:ifclabel + + :param description + :type description:ifctext + + :param hasexternalreference + :type hasexternalreference:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + ''' + def __init__( self , role,userdefinedrole,description, ): + self.role = role + self.userdefinedrole = userdefinedrole + self.description = description + + @apply + def role(): + def fget( self ): + return self._role + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument role is mantatory and can not be set to None') + if not check_type(value,ifcroleenum): + self._role = ifcroleenum(value) + else: + self._role = value + return property(**locals()) + + @apply + def userdefinedrole(): + def fget( self ): + return self._userdefinedrole + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedrole = ifclabel(value) + else: + self._userdefinedrole = value + else: + self._userdefinedrole = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def hasexternalreference(): + def fget( self ): + return self._hasexternalreference + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreference is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((self.role != ifcroleenum.self.userdefined) or ((self.role == ifcroleenum.self.userdefined) and EXISTS(self.self.userdefinedrole))) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcinterceptortype # +#################### +class ifcinterceptortype(ifcflowtreatmentdevicetype): + '''Entity ifcinterceptortype definition. + + :param predefinedtype + :type predefinedtype:ifcinterceptortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowtreatmentdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcinterceptortypeenum): + self._predefinedtype = ifcinterceptortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcinterceptortypeenum.self.userdefined) or ((self.predefinedtype == ifcinterceptortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpolyline # +#################### +class ifcpolyline(ifcboundedcurve): + '''Entity ifcpolyline definition. + + :param points + :type points:LIST(2,None,'ifccartesianpoint', scope = schema_scope) + ''' + def __init__( self , points, ): + ifcboundedcurve.__init__(self , ) + self.points = points + + @apply + def points(): + def fget( self ): + return self._points + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument points is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'ifccartesianpoint', scope = schema_scope)): + self._points = LIST(value) + else: + self._points = value + return property(**locals()) + def samedim(self): + eval_samedim_wr = (SIZEOF(None) == 0) + if not eval_samedim_wr: + raise AssertionError('Rule samedim violated') + else: + return eval_samedim_wr + + +#################### + # ENTITY ifcpredefinedtextfont # +#################### +class ifcpredefinedtextfont(ifcpredefineditem): + '''Entity ifcpredefinedtextfont definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefineditem.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcsurfacereinforcementarea # +#################### +class ifcsurfacereinforcementarea(ifcstructuralloadorresult): + '''Entity ifcsurfacereinforcementarea definition. + + :param surfacereinforcement1 + :type surfacereinforcement1:LIST(2,3,'REAL', scope = schema_scope) + + :param surfacereinforcement2 + :type surfacereinforcement2:LIST(2,3,'REAL', scope = schema_scope) + + :param shearreinforcement + :type shearreinforcement:ifcratiomeasure + ''' + def __init__( self , inherited0__name , surfacereinforcement1,surfacereinforcement2,shearreinforcement, ): + ifcstructuralloadorresult.__init__(self , inherited0__name , ) + self.surfacereinforcement1 = surfacereinforcement1 + self.surfacereinforcement2 = surfacereinforcement2 + self.shearreinforcement = shearreinforcement + + @apply + def surfacereinforcement1(): + def fget( self ): + return self._surfacereinforcement1 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(2,3,'REAL', scope = schema_scope)): + self._surfacereinforcement1 = LIST(value) + else: + self._surfacereinforcement1 = value + else: + self._surfacereinforcement1 = value + return property(**locals()) + + @apply + def surfacereinforcement2(): + def fget( self ): + return self._surfacereinforcement2 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(2,3,'REAL', scope = schema_scope)): + self._surfacereinforcement2 = LIST(value) + else: + self._surfacereinforcement2 = value + else: + self._surfacereinforcement2 = value + return property(**locals()) + + @apply + def shearreinforcement(): + def fget( self ): + return self._shearreinforcement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcratiomeasure): + self._shearreinforcement = ifcratiomeasure(value) + else: + self._shearreinforcement = value + else: + self._shearreinforcement = value + return property(**locals()) + def surfaceandorshearareaspecified(self): + eval_surfaceandorshearareaspecified_wr = ((EXISTS(self.surfacereinforcement1) or EXISTS(self.surfacereinforcement2)) or EXISTS(self.shearreinforcement)) + if not eval_surfaceandorshearareaspecified_wr: + raise AssertionError('Rule surfaceandorshearareaspecified violated') + else: + return eval_surfaceandorshearareaspecified_wr + + def nonnegativearea1(self): + eval_nonnegativearea1_wr = (( not EXISTS(self.surfacereinforcement1)) or (((self.surfacereinforcement1[1] >= 0) and (self.surfacereinforcement1[2] >= 0)) and ((SIZEOF(self.surfacereinforcement1) == 1) or (self.surfacereinforcement1[1] >= 0)))) + if not eval_nonnegativearea1_wr: + raise AssertionError('Rule nonnegativearea1 violated') + else: + return eval_nonnegativearea1_wr + + def nonnegativearea2(self): + eval_nonnegativearea2_wr = (( not EXISTS(self.surfacereinforcement2)) or (((self.surfacereinforcement2[1] >= 0) and (self.surfacereinforcement2[2] >= 0)) and ((SIZEOF(self.surfacereinforcement2) == 1) or (self.surfacereinforcement2[1] >= 0)))) + if not eval_nonnegativearea2_wr: + raise AssertionError('Rule nonnegativearea2 violated') + else: + return eval_nonnegativearea2_wr + + def nonnegativearea3(self): + eval_nonnegativearea3_wr = (( not EXISTS(self.shearreinforcement)) or (self.shearreinforcement >= 0)) + if not eval_nonnegativearea3_wr: + raise AssertionError('Rule nonnegativearea3 violated') + else: + return eval_nonnegativearea3_wr + + +#################### + # ENTITY ifcgeometriccurveset # +#################### +class ifcgeometriccurveset(ifcgeometricset): + '''Entity ifcgeometriccurveset definition. + ''' + def __init__( self , inherited0__elements , ): + ifcgeometricset.__init__(self , inherited0__elements , ) + def nosurfaces(self): + eval_nosurfaces_wr = (SIZEOF(None) == 0) + if not eval_nosurfaces_wr: + raise AssertionError('Rule nosurfaces violated') + else: + return eval_nosurfaces_wr + + +#################### + # ENTITY ifctablerow # +#################### +class ifctablerow(BaseEntityClass): + '''Entity ifctablerow definition. + + :param rowcells + :type rowcells:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param isheading + :type isheading:BOOLEAN + + :param oftable + :type oftable:ifctable + ''' + def __init__( self , rowcells,isheading, ): + self.rowcells = rowcells + self.isheading = isheading + + @apply + def rowcells(): + def fget( self ): + return self._rowcells + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._rowcells = LIST(value) + else: + self._rowcells = value + else: + self._rowcells = value + return property(**locals()) + + @apply + def isheading(): + def fget( self ): + return self._isheading + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._isheading = BOOLEAN(value) + else: + self._isheading = value + else: + self._isheading = value + return property(**locals()) + + @apply + def oftable(): + def fget( self ): + return self._oftable + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument oftable is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcconnectionsurfacegeometry # +#################### +class ifcconnectionsurfacegeometry(ifcconnectiongeometry): + '''Entity ifcconnectionsurfacegeometry definition. + + :param surfaceonrelatingelement + :type surfaceonrelatingelement:ifcsurfaceorfacesurface + + :param surfaceonrelatedelement + :type surfaceonrelatedelement:ifcsurfaceorfacesurface + ''' + def __init__( self , surfaceonrelatingelement,surfaceonrelatedelement, ): + ifcconnectiongeometry.__init__(self , ) + self.surfaceonrelatingelement = surfaceonrelatingelement + self.surfaceonrelatedelement = surfaceonrelatedelement + + @apply + def surfaceonrelatingelement(): + def fget( self ): + return self._surfaceonrelatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument surfaceonrelatingelement is mantatory and can not be set to None') + if not check_type(value,ifcsurfaceorfacesurface): + self._surfaceonrelatingelement = ifcsurfaceorfacesurface(value) + else: + self._surfaceonrelatingelement = value + return property(**locals()) + + @apply + def surfaceonrelatedelement(): + def fget( self ): + return self._surfaceonrelatedelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsurfaceorfacesurface): + self._surfaceonrelatedelement = ifcsurfaceorfacesurface(value) + else: + self._surfaceonrelatedelement = value + else: + self._surfaceonrelatedelement = value + return property(**locals()) + +#################### + # ENTITY ifcelectricdistributionboardtype # +#################### +class ifcelectricdistributionboardtype(ifcflowcontrollertype): + '''Entity ifcelectricdistributionboardtype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricdistributionboardtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricdistributionboardtypeenum): + self._predefinedtype = ifcelectricdistributionboardtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcelectricdistributionboardtypeenum.self.userdefined) or ((self.predefinedtype == ifcelectricdistributionboardtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcderivedprofiledef # +#################### +class ifcderivedprofiledef(ifcprofiledef): + '''Entity ifcderivedprofiledef definition. + + :param parentprofile + :type parentprofile:ifcprofiledef + + :param operator + :type operator:ifccartesiantransformationoperator2d + + :param label + :type label:ifclabel + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , parentprofile,operator,label, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.parentprofile = parentprofile + self.operator = operator + self.label = label + + @apply + def parentprofile(): + def fget( self ): + return self._parentprofile + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parentprofile is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._parentprofile = ifcprofiledef(value) + else: + self._parentprofile = value + return property(**locals()) + + @apply + def operator(): + def fget( self ): + return self._operator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operator is mantatory and can not be set to None') + if not check_type(value,ifccartesiantransformationoperator2d): + self._operator = ifccartesiantransformationoperator2d(value) + else: + self._operator = value + return property(**locals()) + + @apply + def label(): + def fget( self ): + return self._label + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._label = ifclabel(value) + else: + self._label = value + else: + self._label = value + return property(**locals()) + def invariantprofiletype(self): + eval_invariantprofiletype_wr = (self.self.ifcprofiledef.self.profiletype == self.parentprofile.self.profiletype) + if not eval_invariantprofiletype_wr: + raise AssertionError('Rule invariantprofiletype violated') + else: + return eval_invariantprofiletype_wr + + +#################### + # ENTITY ifcflowmovingdevicetype # +#################### +class ifcflowmovingdevicetype(ifcdistributionflowelementtype): + '''Entity ifcflowmovingdevicetype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcfantype # +#################### +class ifcfantype(ifcflowmovingdevicetype): + '''Entity ifcfantype definition. + + :param predefinedtype + :type predefinedtype:ifcfantypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowmovingdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcfantypeenum): + self._predefinedtype = ifcfantypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcfantypeenum.self.userdefined) or ((self.predefinedtype == ifcfantypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcobjectplacement # +#################### +class ifcobjectplacement(BaseEntityClass): + '''Entity ifcobjectplacement definition. + + :param placesobject + :type placesobject:SET(0,None,'ifcproduct', scope = schema_scope) + + :param referencedbyplacements + :type referencedbyplacements:SET(0,None,'ifclocalplacement', scope = schema_scope) + ''' + # This class does not define any attribute. + pass + + @apply + def placesobject(): + def fget( self ): + return self._placesobject + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument placesobject is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def referencedbyplacements(): + def fget( self ): + return self._referencedbyplacements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument referencedbyplacements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcgridplacement # +#################### +class ifcgridplacement(ifcobjectplacement): + '''Entity ifcgridplacement definition. + + :param placementlocation + :type placementlocation:ifcvirtualgridintersection + + :param placementrefdirection + :type placementrefdirection:ifcgridplacementdirectionselect + ''' + def __init__( self , placementlocation,placementrefdirection, ): + ifcobjectplacement.__init__(self , ) + self.placementlocation = placementlocation + self.placementrefdirection = placementrefdirection + + @apply + def placementlocation(): + def fget( self ): + return self._placementlocation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument placementlocation is mantatory and can not be set to None') + if not check_type(value,ifcvirtualgridintersection): + self._placementlocation = ifcvirtualgridintersection(value) + else: + self._placementlocation = value + return property(**locals()) + + @apply + def placementrefdirection(): + def fget( self ): + return self._placementrefdirection + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcgridplacementdirectionselect): + self._placementrefdirection = ifcgridplacementdirectionselect(value) + else: + self._placementrefdirection = value + else: + self._placementrefdirection = value + return property(**locals()) + +#################### + # ENTITY ifctextstylefontmodel # +#################### +class ifctextstylefontmodel(ifcpredefinedtextfont): + '''Entity ifctextstylefontmodel definition. + + :param fontfamily + :type fontfamily:LIST(1,None,'STRING', scope = schema_scope) + + :param fontstyle + :type fontstyle:ifcfontstyle + + :param fontvariant + :type fontvariant:ifcfontvariant + + :param fontweight + :type fontweight:ifcfontweight + + :param fontsize + :type fontsize:ifcsizeselect + ''' + def __init__( self , inherited0__name , fontfamily,fontstyle,fontvariant,fontweight,fontsize, ): + ifcpredefinedtextfont.__init__(self , inherited0__name , ) + self.fontfamily = fontfamily + self.fontstyle = fontstyle + self.fontvariant = fontvariant + self.fontweight = fontweight + self.fontsize = fontsize + + @apply + def fontfamily(): + def fget( self ): + return self._fontfamily + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fontfamily is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._fontfamily = LIST(value) + else: + self._fontfamily = value + return property(**locals()) + + @apply + def fontstyle(): + def fget( self ): + return self._fontstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfontstyle): + self._fontstyle = ifcfontstyle(value) + else: + self._fontstyle = value + else: + self._fontstyle = value + return property(**locals()) + + @apply + def fontvariant(): + def fget( self ): + return self._fontvariant + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfontvariant): + self._fontvariant = ifcfontvariant(value) + else: + self._fontvariant = value + else: + self._fontvariant = value + return property(**locals()) + + @apply + def fontweight(): + def fget( self ): + return self._fontweight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfontweight): + self._fontweight = ifcfontweight(value) + else: + self._fontweight = value + else: + self._fontweight = value + return property(**locals()) + + @apply + def fontsize(): + def fget( self ): + return self._fontsize + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fontsize is mantatory and can not be set to None') + if not check_type(value,ifcsizeselect): + self._fontsize = ifcsizeselect(value) + else: + self._fontsize = value + return property(**locals()) + def measureoffontsize(self): + eval_measureoffontsize_wr = (('IFC4.IFCLENGTHMEASURE' == TYPEOF(self.self.fontsize)) and (self.self.fontsize > 0)) + if not eval_measureoffontsize_wr: + raise AssertionError('Rule measureoffontsize violated') + else: + return eval_measureoffontsize_wr + + +#################### + # ENTITY ifcprotectivedevicetype # +#################### +class ifcprotectivedevicetype(ifcflowcontrollertype): + '''Entity ifcprotectivedevicetype definition. + + :param predefinedtype + :type predefinedtype:ifcprotectivedevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcprotectivedevicetypeenum): + self._predefinedtype = ifcprotectivedevicetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcprotectivedevicetypeenum.self.userdefined) or ((self.predefinedtype == ifcprotectivedevicetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcsensor # +#################### +class ifcsensor(ifcdistributioncontrolelement): + '''Entity ifcsensor definition. + + :param predefinedtype + :type predefinedtype:ifcsensortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcdistributioncontrolelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsensortypeenum): + self._predefinedtype = ifcsensortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcsensortypeenum.self.userdefined)) or ((self.predefinedtype == ifcsensortypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSENSORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifccircleprofiledef # +#################### +class ifccircleprofiledef(ifcparameterizedprofiledef): + '''Entity ifccircleprofiledef definition. + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , radius, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifccolourrgblist # +#################### +class ifccolourrgblist(ifcpresentationitem): + '''Entity ifccolourrgblist definition. + + :param colourlist + :type colourlist:LIST(1,None,LIST(3,3,'REAL', scope = schema_scope)) + ''' + def __init__( self , colourlist, ): + ifcpresentationitem.__init__(self , ) + self.colourlist = colourlist + + @apply + def colourlist(): + def fget( self ): + return self._colourlist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colourlist is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,LIST(3,3,'REAL', scope = schema_scope))): + self._colourlist = LIST(value) + else: + self._colourlist = value + return property(**locals()) + +#################### + # ENTITY ifcmaterialconstituent # +#################### +class ifcmaterialconstituent(ifcmaterialdefinition): + '''Entity ifcmaterialconstituent definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param material + :type material:ifcmaterial + + :param fraction + :type fraction:ifcnormalisedratiomeasure + + :param category + :type category:ifclabel + + :param tomaterialconstituentset + :type tomaterialconstituentset:ifcmaterialconstituentset + ''' + def __init__( self , name,description,material,fraction,category, ): + ifcmaterialdefinition.__init__(self , ) + self.name = name + self.description = description + self.material = material + self.fraction = fraction + self.category = category + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def material(): + def fget( self ): + return self._material + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument material is mantatory and can not be set to None') + if not check_type(value,ifcmaterial): + self._material = ifcmaterial(value) + else: + self._material = value + return property(**locals()) + + @apply + def fraction(): + def fget( self ): + return self._fraction + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._fraction = ifcnormalisedratiomeasure(value) + else: + self._fraction = value + else: + self._fraction = value + return property(**locals()) + + @apply + def category(): + def fget( self ): + return self._category + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._category = ifclabel(value) + else: + self._category = value + else: + self._category = value + return property(**locals()) + + @apply + def tomaterialconstituentset(): + def fget( self ): + return self._tomaterialconstituentset + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument tomaterialconstituentset is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcwindowpanelproperties # +#################### +class ifcwindowpanelproperties(ifcpredefinedpropertyset): + '''Entity ifcwindowpanelproperties definition. + + :param operationtype + :type operationtype:ifcwindowpaneloperationenum + + :param panelposition + :type panelposition:ifcwindowpanelpositionenum + + :param framedepth + :type framedepth:ifcpositivelengthmeasure + + :param framethickness + :type framethickness:ifcpositivelengthmeasure + + :param shapeaspectstyle + :type shapeaspectstyle:ifcshapeaspect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , operationtype,panelposition,framedepth,framethickness,shapeaspectstyle, ): + ifcpredefinedpropertyset.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.operationtype = operationtype + self.panelposition = panelposition + self.framedepth = framedepth + self.framethickness = framethickness + self.shapeaspectstyle = shapeaspectstyle + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operationtype is mantatory and can not be set to None') + if not check_type(value,ifcwindowpaneloperationenum): + self._operationtype = ifcwindowpaneloperationenum(value) + else: + self._operationtype = value + return property(**locals()) + + @apply + def panelposition(): + def fget( self ): + return self._panelposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument panelposition is mantatory and can not be set to None') + if not check_type(value,ifcwindowpanelpositionenum): + self._panelposition = ifcwindowpanelpositionenum(value) + else: + self._panelposition = value + return property(**locals()) + + @apply + def framedepth(): + def fget( self ): + return self._framedepth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._framedepth = ifcpositivelengthmeasure(value) + else: + self._framedepth = value + else: + self._framedepth = value + return property(**locals()) + + @apply + def framethickness(): + def fget( self ): + return self._framethickness + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._framethickness = ifcpositivelengthmeasure(value) + else: + self._framethickness = value + else: + self._framethickness = value + return property(**locals()) + + @apply + def shapeaspectstyle(): + def fget( self ): + return self._shapeaspectstyle + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcshapeaspect): + self._shapeaspectstyle = ifcshapeaspect(value) + else: + self._shapeaspectstyle = value + else: + self._shapeaspectstyle = value + return property(**locals()) + def applicabletotype(self): + eval_applicabletotype_wr = (EXISTS(self.self.ifcpropertysetdefinition.self.definestype[1]) and (('IFC4.IFCWINDOWTYPE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1])) or ('IFC4.IFCWINDOWSTYLE' == TYPEOF(self.self.ifcpropertysetdefinition.self.definestype[1])))) + if not eval_applicabletotype_wr: + raise AssertionError('Rule applicabletotype violated') + else: + return eval_applicabletotype_wr + + +#################### + # ENTITY ifcelectrictimecontrol # +#################### +class ifcelectrictimecontrol(ifcflowcontroller): + '''Entity ifcelectrictimecontrol definition. + + :param predefinedtype + :type predefinedtype:ifcelectrictimecontroltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowcontroller.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelectrictimecontroltypeenum): + self._predefinedtype = ifcelectrictimecontroltypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcelectrictimecontroltypeenum.self.userdefined)) or ((self.predefinedtype == ifcelectrictimecontroltypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCELECTRICTIMECONTROLTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcdimensionalexponents # +#################### +class ifcdimensionalexponents(BaseEntityClass): + '''Entity ifcdimensionalexponents definition. + + :param lengthexponent + :type lengthexponent:INTEGER + + :param massexponent + :type massexponent:INTEGER + + :param timeexponent + :type timeexponent:INTEGER + + :param electriccurrentexponent + :type electriccurrentexponent:INTEGER + + :param thermodynamictemperatureexponent + :type thermodynamictemperatureexponent:INTEGER + + :param amountofsubstanceexponent + :type amountofsubstanceexponent:INTEGER + + :param luminousintensityexponent + :type luminousintensityexponent:INTEGER + ''' + def __init__( self , lengthexponent,massexponent,timeexponent,electriccurrentexponent,thermodynamictemperatureexponent,amountofsubstanceexponent,luminousintensityexponent, ): + self.lengthexponent = lengthexponent + self.massexponent = massexponent + self.timeexponent = timeexponent + self.electriccurrentexponent = electriccurrentexponent + self.thermodynamictemperatureexponent = thermodynamictemperatureexponent + self.amountofsubstanceexponent = amountofsubstanceexponent + self.luminousintensityexponent = luminousintensityexponent + + @apply + def lengthexponent(): + def fget( self ): + return self._lengthexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lengthexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._lengthexponent = INTEGER(value) + else: + self._lengthexponent = value + return property(**locals()) + + @apply + def massexponent(): + def fget( self ): + return self._massexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument massexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._massexponent = INTEGER(value) + else: + self._massexponent = value + return property(**locals()) + + @apply + def timeexponent(): + def fget( self ): + return self._timeexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timeexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._timeexponent = INTEGER(value) + else: + self._timeexponent = value + return property(**locals()) + + @apply + def electriccurrentexponent(): + def fget( self ): + return self._electriccurrentexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument electriccurrentexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._electriccurrentexponent = INTEGER(value) + else: + self._electriccurrentexponent = value + return property(**locals()) + + @apply + def thermodynamictemperatureexponent(): + def fget( self ): + return self._thermodynamictemperatureexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument thermodynamictemperatureexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._thermodynamictemperatureexponent = INTEGER(value) + else: + self._thermodynamictemperatureexponent = value + return property(**locals()) + + @apply + def amountofsubstanceexponent(): + def fget( self ): + return self._amountofsubstanceexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument amountofsubstanceexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._amountofsubstanceexponent = INTEGER(value) + else: + self._amountofsubstanceexponent = value + return property(**locals()) + + @apply + def luminousintensityexponent(): + def fget( self ): + return self._luminousintensityexponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument luminousintensityexponent is mantatory and can not be set to None') + if not check_type(value,INTEGER): + self._luminousintensityexponent = INTEGER(value) + else: + self._luminousintensityexponent = value + return property(**locals()) + +#################### + # ENTITY ifcmetric # +#################### +class ifcmetric(ifcconstraint): + '''Entity ifcmetric definition. + + :param benchmark + :type benchmark:ifcbenchmarkenum + + :param valuesource + :type valuesource:ifclabel + + :param datavalue + :type datavalue:ifcmetricvalueselect + + :param referencepath + :type referencepath:ifcreference + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__constraintgrade , inherited3__constraintsource , inherited4__creatingactor , inherited5__creationtime , inherited6__userdefinedgrade , benchmark,valuesource,datavalue,referencepath, ): + ifcconstraint.__init__(self , inherited0__name , inherited1__description , inherited2__constraintgrade , inherited3__constraintsource , inherited4__creatingactor , inherited5__creationtime , inherited6__userdefinedgrade , ) + self.benchmark = benchmark + self.valuesource = valuesource + self.datavalue = datavalue + self.referencepath = referencepath + + @apply + def benchmark(): + def fget( self ): + return self._benchmark + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument benchmark is mantatory and can not be set to None') + if not check_type(value,ifcbenchmarkenum): + self._benchmark = ifcbenchmarkenum(value) + else: + self._benchmark = value + return property(**locals()) + + @apply + def valuesource(): + def fget( self ): + return self._valuesource + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._valuesource = ifclabel(value) + else: + self._valuesource = value + else: + self._valuesource = value + return property(**locals()) + + @apply + def datavalue(): + def fget( self ): + return self._datavalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument datavalue is mantatory and can not be set to None') + if not check_type(value,ifcmetricvalueselect): + self._datavalue = ifcmetricvalueselect(value) + else: + self._datavalue = value + return property(**locals()) + + @apply + def referencepath(): + def fget( self ): + return self._referencepath + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreference): + self._referencepath = ifcreference(value) + else: + self._referencepath = value + else: + self._referencepath = value + return property(**locals()) + +#################### + # ENTITY ifcunitarycontrolelementtype # +#################### +class ifcunitarycontrolelementtype(ifcdistributioncontrolelementtype): + '''Entity ifcunitarycontrolelementtype definition. + + :param predefinedtype + :type predefinedtype:ifcunitarycontrolelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcunitarycontrolelementtypeenum): + self._predefinedtype = ifcunitarycontrolelementtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcunitarycontrolelementtypeenum.self.userdefined) or ((self.predefinedtype == ifcunitarycontrolelementtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccablefittingtype # +#################### +class ifccablefittingtype(ifcflowfittingtype): + '''Entity ifccablefittingtype definition. + + :param predefinedtype + :type predefinedtype:ifccablefittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowfittingtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccablefittingtypeenum): + self._predefinedtype = ifccablefittingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccablefittingtypeenum.self.userdefined) or ((self.predefinedtype == ifccablefittingtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcrelconnectswithrealizingelements # +#################### +class ifcrelconnectswithrealizingelements(ifcrelconnectselements): + '''Entity ifcrelconnectswithrealizingelements definition. + + :param realizingelements + :type realizingelements:SET(1,None,'ifcelement', scope = schema_scope) + + :param connectiontype + :type connectiontype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__connectiongeometry , inherited5__relatingelement , inherited6__relatedelement , realizingelements,connectiontype, ): + ifcrelconnectselements.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__connectiongeometry , inherited5__relatingelement , inherited6__relatedelement , ) + self.realizingelements = realizingelements + self.connectiontype = connectiontype + + @apply + def realizingelements(): + def fget( self ): + return self._realizingelements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument realizingelements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcelement', scope = schema_scope)): + self._realizingelements = SET(value) + else: + self._realizingelements = value + return property(**locals()) + + @apply + def connectiontype(): + def fget( self ): + return self._connectiontype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._connectiontype = ifclabel(value) + else: + self._connectiontype = value + else: + self._connectiontype = value + return property(**locals()) + +#################### + # ENTITY ifcprocess # +#################### +class ifcprocess(ifcobject): + '''Entity ifcprocess definition. + + :param identification + :type identification:ifcidentifier + + :param longdescription + :type longdescription:ifctext + + :param ispredecessorto + :type ispredecessorto:SET(0,None,'ifcrelsequence', scope = schema_scope) + + :param issuccessorfrom + :type issuccessorfrom:SET(0,None,'ifcrelsequence', scope = schema_scope) + + :param operateson + :type operateson:SET(0,None,'ifcrelassignstoprocess', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , identification,longdescription, ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.identification = identification + self.longdescription = longdescription + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + else: + self._identification = value + return property(**locals()) + + @apply + def longdescription(): + def fget( self ): + return self._longdescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._longdescription = ifctext(value) + else: + self._longdescription = value + else: + self._longdescription = value + return property(**locals()) + + @apply + def ispredecessorto(): + def fget( self ): + return self._ispredecessorto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument ispredecessorto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def issuccessorfrom(): + def fget( self ): + return self._issuccessorfrom + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument issuccessorfrom is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def operateson(): + def fget( self ): + return self._operateson + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument operateson is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifctask # +#################### +class ifctask(ifcprocess): + '''Entity ifctask definition. + + :param status + :type status:ifclabel + + :param workmethod + :type workmethod:ifclabel + + :param ismilestone + :type ismilestone:BOOLEAN + + :param priority + :type priority:INTEGER + + :param tasktime + :type tasktime:ifctasktime + + :param predefinedtype + :type predefinedtype:ifctasktypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , status,workmethod,ismilestone,priority,tasktime,predefinedtype, ): + ifcprocess.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , ) + self.status = status + self.workmethod = workmethod + self.ismilestone = ismilestone + self.priority = priority + self.tasktime = tasktime + self.predefinedtype = predefinedtype + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._status = ifclabel(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def workmethod(): + def fget( self ): + return self._workmethod + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._workmethod = ifclabel(value) + else: + self._workmethod = value + else: + self._workmethod = value + return property(**locals()) + + @apply + def ismilestone(): + def fget( self ): + return self._ismilestone + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ismilestone is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._ismilestone = BOOLEAN(value) + else: + self._ismilestone = value + return property(**locals()) + + @apply + def priority(): + def fget( self ): + return self._priority + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,INTEGER): + self._priority = INTEGER(value) + else: + self._priority = value + else: + self._priority = value + return property(**locals()) + + @apply + def tasktime(): + def fget( self ): + return self._tasktime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctasktime): + self._tasktime = ifctasktime(value) + else: + self._tasktime = value + else: + self._tasktime = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctasktypeenum): + self._predefinedtype = ifctasktypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def hasname(self): + eval_hasname_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_hasname_wr: + raise AssertionError('Rule hasname violated') + else: + return eval_hasname_wr + + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifctasktypeenum.self.userdefined)) or ((self.predefinedtype == ifctasktypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcresource # +#################### +class ifcresource(ifcobject): + '''Entity ifcresource definition. + + :param identification + :type identification:ifcidentifier + + :param longdescription + :type longdescription:ifctext + + :param resourceof + :type resourceof:SET(0,None,'ifcrelassignstoresource', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , identification,longdescription, ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.identification = identification + self.longdescription = longdescription + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + else: + self._identification = value + return property(**locals()) + + @apply + def longdescription(): + def fget( self ): + return self._longdescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._longdescription = ifctext(value) + else: + self._longdescription = value + else: + self._longdescription = value + return property(**locals()) + + @apply + def resourceof(): + def fget( self ): + return self._resourceof + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument resourceof is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcconstructionresource # +#################### +class ifcconstructionresource(ifcresource): + '''Entity ifcconstructionresource definition. + + :param usage + :type usage:ifcresourcetime + + :param basecosts + :type basecosts:LIST(1,None,'ifcappliedvalue', scope = schema_scope) + + :param basequantity + :type basequantity:ifcphysicalquantity + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , usage,basecosts,basequantity, ): + ifcresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , ) + self.usage = usage + self.basecosts = basecosts + self.basequantity = basequantity + + @apply + def usage(): + def fget( self ): + return self._usage + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcresourcetime): + self._usage = ifcresourcetime(value) + else: + self._usage = value + else: + self._usage = value + return property(**locals()) + + @apply + def basecosts(): + def fget( self ): + return self._basecosts + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcappliedvalue', scope = schema_scope)): + self._basecosts = LIST(value) + else: + self._basecosts = value + else: + self._basecosts = value + return property(**locals()) + + @apply + def basequantity(): + def fget( self ): + return self._basequantity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcphysicalquantity): + self._basequantity = ifcphysicalquantity(value) + else: + self._basequantity = value + else: + self._basequantity = value + return property(**locals()) + +#################### + # ENTITY ifccrewresource # +#################### +class ifccrewresource(ifcconstructionresource): + '''Entity ifccrewresource definition. + + :param predefinedtype + :type predefinedtype:ifccrewresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , predefinedtype, ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccrewresourcetypeenum): + self._predefinedtype = ifccrewresourcetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccrewresourcetypeenum.self.userdefined)) or ((self.predefinedtype == ifccrewresourcetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcunitarycontrolelement # +#################### +class ifcunitarycontrolelement(ifcdistributioncontrolelement): + '''Entity ifcunitarycontrolelement definition. + + :param predefinedtype + :type predefinedtype:ifcunitarycontrolelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcdistributioncontrolelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunitarycontrolelementtypeenum): + self._predefinedtype = ifcunitarycontrolelementtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcunitarycontrolelementtypeenum.self.userdefined)) or ((self.predefinedtype == ifcunitarycontrolelementtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCUNITARYCONTROLELEMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcfacetedbrep # +#################### +class ifcfacetedbrep(ifcmanifoldsolidbrep): + '''Entity ifcfacetedbrep definition. + ''' + def __init__( self , inherited0__outer , ): + ifcmanifoldsolidbrep.__init__(self , inherited0__outer , ) + +#################### + # ENTITY ifclamp # +#################### +class ifclamp(ifcflowterminal): + '''Entity ifclamp definition. + + :param predefinedtype + :type predefinedtype:ifclamptypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclamptypeenum): + self._predefinedtype = ifclamptypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifclamptypeenum.self.userdefined)) or ((self.predefinedtype == ifclamptypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCLAMPTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcbooleanresult # +#################### +class ifcbooleanresult(ifcgeometricrepresentationitem): + '''Entity ifcbooleanresult definition. + + :param operator + :type operator:ifcbooleanoperator + + :param firstoperand + :type firstoperand:ifcbooleanoperand + + :param secondoperand + :type secondoperand:ifcbooleanoperand + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , operator,firstoperand,secondoperand, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.operator = operator + self.firstoperand = firstoperand + self.secondoperand = secondoperand + + @apply + def operator(): + def fget( self ): + return self._operator + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operator is mantatory and can not be set to None') + if not check_type(value,ifcbooleanoperator): + self._operator = ifcbooleanoperator(value) + else: + self._operator = value + return property(**locals()) + + @apply + def firstoperand(): + def fget( self ): + return self._firstoperand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument firstoperand is mantatory and can not be set to None') + if not check_type(value,ifcbooleanoperand): + self._firstoperand = ifcbooleanoperand(value) + else: + self._firstoperand = value + return property(**locals()) + + @apply + def secondoperand(): + def fget( self ): + return self._secondoperand + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument secondoperand is mantatory and can not be set to None') + if not check_type(value,ifcbooleanoperand): + self._secondoperand = ifcbooleanoperand(value) + else: + self._secondoperand = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.firstoperand.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def samedim(self): + eval_samedim_wr = (self.firstoperand.self.dim == self.secondoperand.self.dim) + if not eval_samedim_wr: + raise AssertionError('Rule samedim violated') + else: + return eval_samedim_wr + + +#################### + # ENTITY ifcslabtype # +#################### +class ifcslabtype(ifcbuildingelementtype): + '''Entity ifcslabtype definition. + + :param predefinedtype + :type predefinedtype:ifcslabtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcslabtypeenum): + self._predefinedtype = ifcslabtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcslabtypeenum.self.userdefined) or ((self.predefinedtype == ifcslabtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcelectricgenerator # +#################### +class ifcelectricgenerator(ifcenergyconversiondevice): + '''Entity ifcelectricgenerator definition. + + :param predefinedtype + :type predefinedtype:ifcelectricgeneratortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelectricgeneratortypeenum): + self._predefinedtype = ifcelectricgeneratortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcelectricgeneratortypeenum.self.userdefined)) or ((self.predefinedtype == ifcelectricgeneratortypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCELECTRICGENERATORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifctextstyletextmodel # +#################### +class ifctextstyletextmodel(ifcpresentationitem): + '''Entity ifctextstyletextmodel definition. + + :param textindent + :type textindent:ifcsizeselect + + :param textalign + :type textalign:ifctextalignment + + :param textdecoration + :type textdecoration:ifctextdecoration + + :param letterspacing + :type letterspacing:ifcsizeselect + + :param wordspacing + :type wordspacing:ifcsizeselect + + :param texttransform + :type texttransform:ifctexttransformation + + :param lineheight + :type lineheight:ifcsizeselect + ''' + def __init__( self , textindent,textalign,textdecoration,letterspacing,wordspacing,texttransform,lineheight, ): + ifcpresentationitem.__init__(self , ) + self.textindent = textindent + self.textalign = textalign + self.textdecoration = textdecoration + self.letterspacing = letterspacing + self.wordspacing = wordspacing + self.texttransform = texttransform + self.lineheight = lineheight + + @apply + def textindent(): + def fget( self ): + return self._textindent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._textindent = ifcsizeselect(value) + else: + self._textindent = value + else: + self._textindent = value + return property(**locals()) + + @apply + def textalign(): + def fget( self ): + return self._textalign + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctextalignment): + self._textalign = ifctextalignment(value) + else: + self._textalign = value + else: + self._textalign = value + return property(**locals()) + + @apply + def textdecoration(): + def fget( self ): + return self._textdecoration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctextdecoration): + self._textdecoration = ifctextdecoration(value) + else: + self._textdecoration = value + else: + self._textdecoration = value + return property(**locals()) + + @apply + def letterspacing(): + def fget( self ): + return self._letterspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._letterspacing = ifcsizeselect(value) + else: + self._letterspacing = value + else: + self._letterspacing = value + return property(**locals()) + + @apply + def wordspacing(): + def fget( self ): + return self._wordspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._wordspacing = ifcsizeselect(value) + else: + self._wordspacing = value + else: + self._wordspacing = value + return property(**locals()) + + @apply + def texttransform(): + def fget( self ): + return self._texttransform + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctexttransformation): + self._texttransform = ifctexttransformation(value) + else: + self._texttransform = value + else: + self._texttransform = value + return property(**locals()) + + @apply + def lineheight(): + def fget( self ): + return self._lineheight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._lineheight = ifcsizeselect(value) + else: + self._lineheight = value + else: + self._lineheight = value + return property(**locals()) + +#################### + # ENTITY ifcunitassignment # +#################### +class ifcunitassignment(BaseEntityClass): + '''Entity ifcunitassignment definition. + + :param units + :type units:SET(1,None,'ifcunit', scope = schema_scope) + ''' + def __init__( self , units, ): + self.units = units + + @apply + def units(): + def fget( self ): + return self._units + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument units is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcunit', scope = schema_scope)): + self._units = SET(value) + else: + self._units = value + return property(**locals()) + def wr01(self): + eval_wr01_wr = ifccorrectunitassignment(self.units) + if not eval_wr01_wr: + raise AssertionError('Rule wr01 violated') + else: + return eval_wr01_wr + + +#################### + # ENTITY ifcbeam # +#################### +class ifcbeam(ifcbuildingelement): + '''Entity ifcbeam definition. + + :param predefinedtype + :type predefinedtype:ifcbeamtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcbeamtypeenum): + self._predefinedtype = ifcbeamtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcbeamtypeenum.self.userdefined)) or ((self.predefinedtype == ifcbeamtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCBEAMTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcplate # +#################### +class ifcplate(ifcbuildingelement): + '''Entity ifcplate definition. + + :param predefinedtype + :type predefinedtype:ifcplatetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplatetypeenum): + self._predefinedtype = ifcplatetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcplatetypeenum.self.userdefined)) or ((self.predefinedtype == ifcplatetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCPLATETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcplatestandardcase # +#################### +class ifcplatestandardcase(ifcplate): + '''Entity ifcplatestandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ): + ifcplate.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ) + def hasmateriallayersetusage(self): + eval_hasmateriallayersetusage_wr = (SIZEOF(None) == 1) + if not eval_hasmateriallayersetusage_wr: + raise AssertionError('Rule hasmateriallayersetusage violated') + else: + return eval_hasmateriallayersetusage_wr + + +#################### + # ENTITY ifcvalve # +#################### +class ifcvalve(ifcflowcontroller): + '''Entity ifcvalve definition. + + :param predefinedtype + :type predefinedtype:ifcvalvetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowcontroller.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvalvetypeenum): + self._predefinedtype = ifcvalvetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcvalvetypeenum.self.userdefined)) or ((self.predefinedtype == ifcvalvetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCVALVETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcairterminalbox # +#################### +class ifcairterminalbox(ifcflowcontroller): + '''Entity ifcairterminalbox definition. + + :param predefinedtype + :type predefinedtype:ifcairterminalboxtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowcontroller.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcairterminalboxtypeenum): + self._predefinedtype = ifcairterminalboxtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcairterminalboxtypeenum.self.userdefined)) or ((self.predefinedtype == ifcairterminalboxtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCAIRTERMINALBOXTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcchiller # +#################### +class ifcchiller(ifcenergyconversiondevice): + '''Entity ifcchiller definition. + + :param predefinedtype + :type predefinedtype:ifcchillertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcchillertypeenum): + self._predefinedtype = ifcchillertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcchillertypeenum.self.userdefined)) or ((self.predefinedtype == ifcchillertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCHILLERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcevaporativecoolertype # +#################### +class ifcevaporativecoolertype(ifcenergyconversiondevicetype): + '''Entity ifcevaporativecoolertype definition. + + :param predefinedtype + :type predefinedtype:ifcevaporativecoolertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcevaporativecoolertypeenum): + self._predefinedtype = ifcevaporativecoolertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcevaporativecoolertypeenum.self.userdefined) or ((self.predefinedtype == ifcevaporativecoolertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcflowmeter # +#################### +class ifcflowmeter(ifcflowcontroller): + '''Entity ifcflowmeter definition. + + :param predefinedtype + :type predefinedtype:ifcflowmetertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowcontroller.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcflowmetertypeenum): + self._predefinedtype = ifcflowmetertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcflowmetertypeenum.self.userdefined)) or ((self.predefinedtype == ifcflowmetertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCFLOWMETERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcelementarysurface # +#################### +class ifcelementarysurface(ifcsurface): + '''Entity ifcelementarysurface definition. + + :param position + :type position:ifcaxis2placement3d + ''' + def __init__( self , position, ): + ifcsurface.__init__(self , ) + self.position = position + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + +#################### + # ENTITY ifcalarmtype # +#################### +class ifcalarmtype(ifcdistributioncontrolelementtype): + '''Entity ifcalarmtype definition. + + :param predefinedtype + :type predefinedtype:ifcalarmtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcalarmtypeenum): + self._predefinedtype = ifcalarmtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcalarmtypeenum.self.userdefined) or ((self.predefinedtype == ifcalarmtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcmembertype # +#################### +class ifcmembertype(ifcbuildingelementtype): + '''Entity ifcmembertype definition. + + :param predefinedtype + :type predefinedtype:ifcmembertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcmembertypeenum): + self._predefinedtype = ifcmembertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcmembertypeenum.self.userdefined) or ((self.predefinedtype == ifcmembertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcrelflowcontrolelements # +#################### +class ifcrelflowcontrolelements(ifcrelconnects): + '''Entity ifcrelflowcontrolelements definition. + + :param relatedcontrolelements + :type relatedcontrolelements:SET(1,None,'ifcdistributioncontrolelement', scope = schema_scope) + + :param relatingflowelement + :type relatingflowelement:ifcdistributionflowelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedcontrolelements,relatingflowelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedcontrolelements = relatedcontrolelements + self.relatingflowelement = relatingflowelement + + @apply + def relatedcontrolelements(): + def fget( self ): + return self._relatedcontrolelements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedcontrolelements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcdistributioncontrolelement', scope = schema_scope)): + self._relatedcontrolelements = SET(value) + else: + self._relatedcontrolelements = value + return property(**locals()) + + @apply + def relatingflowelement(): + def fget( self ): + return self._relatingflowelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingflowelement is mantatory and can not be set to None') + if not check_type(value,ifcdistributionflowelement): + self._relatingflowelement = ifcdistributionflowelement(value) + else: + self._relatingflowelement = value + return property(**locals()) + +#################### + # ENTITY ifcindexedtexturemap # +#################### +class ifcindexedtexturemap(ifctexturecoordinate): + '''Entity ifcindexedtexturemap definition. + + :param mappedto + :type mappedto:ifctessellatedfaceset + + :param texcoords + :type texcoords:ifctexturevertexlist + ''' + def __init__( self , inherited0__maps , mappedto,texcoords, ): + ifctexturecoordinate.__init__(self , inherited0__maps , ) + self.mappedto = mappedto + self.texcoords = texcoords + + @apply + def mappedto(): + def fget( self ): + return self._mappedto + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappedto is mantatory and can not be set to None') + if not check_type(value,ifctessellatedfaceset): + self._mappedto = ifctessellatedfaceset(value) + else: + self._mappedto = value + return property(**locals()) + + @apply + def texcoords(): + def fget( self ): + return self._texcoords + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument texcoords is mantatory and can not be set to None') + if not check_type(value,ifctexturevertexlist): + self._texcoords = ifctexturevertexlist(value) + else: + self._texcoords = value + return property(**locals()) + +#################### + # ENTITY ifcindexedtriangletexturemap # +#################### +class ifcindexedtriangletexturemap(ifcindexedtexturemap): + '''Entity ifcindexedtriangletexturemap definition. + + :param texcoordindex + :type texcoordindex:LIST(1,None,LIST(3,3,'INTEGER', scope = schema_scope)) + ''' + def __init__( self , inherited0__maps , inherited1__mappedto , inherited2__texcoords , texcoordindex, ): + ifcindexedtexturemap.__init__(self , inherited0__maps , inherited1__mappedto , inherited2__texcoords , ) + self.texcoordindex = texcoordindex + + @apply + def texcoordindex(): + def fget( self ): + return self._texcoordindex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,LIST(3,3,'INTEGER', scope = schema_scope))): + self._texcoordindex = LIST(value) + else: + self._texcoordindex = value + else: + self._texcoordindex = value + return property(**locals()) + +#################### + # ENTITY ifcpropertylistvalue # +#################### +class ifcpropertylistvalue(ifcsimpleproperty): + '''Entity ifcpropertylistvalue definition. + + :param listvalues + :type listvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param unit + :type unit:ifcunit + ''' + def __init__( self , inherited0__name , inherited1__description , listvalues,unit, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.listvalues = listvalues + self.unit = unit + + @apply + def listvalues(): + def fget( self ): + return self._listvalues + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._listvalues = LIST(value) + else: + self._listvalues = value + else: + self._listvalues = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (SIZEOF(None) == 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcrelinterfereselements # +#################### +class ifcrelinterfereselements(ifcrelconnects): + '''Entity ifcrelinterfereselements definition. + + :param relatingelement + :type relatingelement:ifcelement + + :param relatedelement + :type relatedelement:ifcelement + + :param interferencegeometry + :type interferencegeometry:ifcconnectiongeometry + + :param interferencetype + :type interferencetype:ifcidentifier + + :param impliedorder + :type impliedorder:LOGICAL + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingelement,relatedelement,interferencegeometry,interferencetype,impliedorder, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingelement = relatingelement + self.relatedelement = relatedelement + self.interferencegeometry = interferencegeometry + self.interferencetype = interferencetype + self.impliedorder = impliedorder + + @apply + def relatingelement(): + def fget( self ): + return self._relatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingelement = ifcelement(value) + else: + self._relatingelement = value + return property(**locals()) + + @apply + def relatedelement(): + def fget( self ): + return self._relatedelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatedelement = ifcelement(value) + else: + self._relatedelement = value + return property(**locals()) + + @apply + def interferencegeometry(): + def fget( self ): + return self._interferencegeometry + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcconnectiongeometry): + self._interferencegeometry = ifcconnectiongeometry(value) + else: + self._interferencegeometry = value + else: + self._interferencegeometry = value + return property(**locals()) + + @apply + def interferencetype(): + def fget( self ): + return self._interferencetype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._interferencetype = ifcidentifier(value) + else: + self._interferencetype = value + else: + self._interferencetype = value + return property(**locals()) + + @apply + def impliedorder(): + def fget( self ): + return self._impliedorder + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument impliedorder is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._impliedorder = LOGICAL(value) + else: + self._impliedorder = value + return property(**locals()) + def notselfreference(self): + eval_notselfreference_wr = (self.relatingelement != self.relatedelement) + if not eval_notselfreference_wr: + raise AssertionError('Rule notselfreference violated') + else: + return eval_notselfreference_wr + + +#################### + # ENTITY ifcsurfacestylerefraction # +#################### +class ifcsurfacestylerefraction(ifcpresentationitem): + '''Entity ifcsurfacestylerefraction definition. + + :param refractionindex + :type refractionindex:ifcreal + + :param dispersionfactor + :type dispersionfactor:ifcreal + ''' + def __init__( self , refractionindex,dispersionfactor, ): + ifcpresentationitem.__init__(self , ) + self.refractionindex = refractionindex + self.dispersionfactor = dispersionfactor + + @apply + def refractionindex(): + def fget( self ): + return self._refractionindex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreal): + self._refractionindex = ifcreal(value) + else: + self._refractionindex = value + else: + self._refractionindex = value + return property(**locals()) + + @apply + def dispersionfactor(): + def fget( self ): + return self._dispersionfactor + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreal): + self._dispersionfactor = ifcreal(value) + else: + self._dispersionfactor = value + else: + self._dispersionfactor = value + return property(**locals()) + +#################### + # ENTITY ifctessellateditem # +#################### +class ifctessellateditem(ifcgeometricrepresentationitem): + '''Entity ifctessellateditem definition. + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifctessellatedfaceset # +#################### +class ifctessellatedfaceset(ifctessellateditem): + '''Entity ifctessellatedfaceset definition. + + :param coordinates + :type coordinates:ifccartesianpointlist3d + + :param normals + :type normals:LIST(1,None,LIST(3,3,'REAL', scope = schema_scope)) + + :param closed + :type closed:BOOLEAN + + :param hascolours + :type hascolours:SET(0,1,'ifcindexedcolourmap', scope = schema_scope) + + :param hastextures + :type hastextures:SET(0,None,'ifcindexedtexturemap', scope = schema_scope) + ''' + def __init__( self , coordinates,normals,closed, ): + ifctessellateditem.__init__(self , ) + self.coordinates = coordinates + self.normals = normals + self.closed = closed + + @apply + def coordinates(): + def fget( self ): + return self._coordinates + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordinates is mantatory and can not be set to None') + if not check_type(value,ifccartesianpointlist3d): + self._coordinates = ifccartesianpointlist3d(value) + else: + self._coordinates = value + return property(**locals()) + + @apply + def normals(): + def fget( self ): + return self._normals + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,LIST(3,3,'REAL', scope = schema_scope))): + self._normals = LIST(value) + else: + self._normals = value + else: + self._normals = value + return property(**locals()) + + @apply + def closed(): + def fget( self ): + return self._closed + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._closed = BOOLEAN(value) + else: + self._closed = value + else: + self._closed = value + return property(**locals()) + + @apply + def hascolours(): + def fget( self ): + return self._hascolours + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hascolours is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hastextures(): + def fget( self ): + return self._hastextures + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hastextures is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcpredefinedcurvefont # +#################### +class ifcpredefinedcurvefont(ifcpredefineditem): + '''Entity ifcpredefinedcurvefont definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefineditem.__init__(self , inherited0__name , ) + +#################### + # ENTITY ifcrampflight # +#################### +class ifcrampflight(ifcbuildingelement): + '''Entity ifcrampflight definition. + + :param predefinedtype + :type predefinedtype:ifcrampflighttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrampflighttypeenum): + self._predefinedtype = ifcrampflighttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcrampflighttypeenum.self.userdefined)) or ((self.predefinedtype == ifcrampflighttypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCRAMPFLIGHTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcdiscreteaccessory # +#################### +class ifcdiscreteaccessory(ifcelementcomponent): + '''Entity ifcdiscreteaccessory definition. + + :param predefinedtype + :type predefinedtype:ifcdiscreteaccessorytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdiscreteaccessorytypeenum): + self._predefinedtype = ifcdiscreteaccessorytypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcdiscreteaccessorytypeenum.self.userdefined)) or ((self.predefinedtype == ifcdiscreteaccessorytypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCDISCRETEACCESSORYTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcperson # +#################### +class ifcperson(BaseEntityClass): + '''Entity ifcperson definition. + + :param identification + :type identification:ifcidentifier + + :param familyname + :type familyname:ifclabel + + :param givenname + :type givenname:ifclabel + + :param middlenames + :type middlenames:LIST(1,None,'STRING', scope = schema_scope) + + :param prefixtitles + :type prefixtitles:LIST(1,None,'STRING', scope = schema_scope) + + :param suffixtitles + :type suffixtitles:LIST(1,None,'STRING', scope = schema_scope) + + :param roles + :type roles:LIST(1,None,'ifcactorrole', scope = schema_scope) + + :param addresses + :type addresses:LIST(1,None,'ifcaddress', scope = schema_scope) + + :param engagedin + :type engagedin:SET(0,None,'ifcpersonandorganization', scope = schema_scope) + ''' + def __init__( self , identification,familyname,givenname,middlenames,prefixtitles,suffixtitles,roles,addresses, ): + self.identification = identification + self.familyname = familyname + self.givenname = givenname + self.middlenames = middlenames + self.prefixtitles = prefixtitles + self.suffixtitles = suffixtitles + self.roles = roles + self.addresses = addresses + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + else: + self._identification = value + return property(**locals()) + + @apply + def familyname(): + def fget( self ): + return self._familyname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._familyname = ifclabel(value) + else: + self._familyname = value + else: + self._familyname = value + return property(**locals()) + + @apply + def givenname(): + def fget( self ): + return self._givenname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._givenname = ifclabel(value) + else: + self._givenname = value + else: + self._givenname = value + return property(**locals()) + + @apply + def middlenames(): + def fget( self ): + return self._middlenames + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._middlenames = LIST(value) + else: + self._middlenames = value + else: + self._middlenames = value + return property(**locals()) + + @apply + def prefixtitles(): + def fget( self ): + return self._prefixtitles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._prefixtitles = LIST(value) + else: + self._prefixtitles = value + else: + self._prefixtitles = value + return property(**locals()) + + @apply + def suffixtitles(): + def fget( self ): + return self._suffixtitles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._suffixtitles = LIST(value) + else: + self._suffixtitles = value + else: + self._suffixtitles = value + return property(**locals()) + + @apply + def roles(): + def fget( self ): + return self._roles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcactorrole', scope = schema_scope)): + self._roles = LIST(value) + else: + self._roles = value + else: + self._roles = value + return property(**locals()) + + @apply + def addresses(): + def fget( self ): + return self._addresses + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcaddress', scope = schema_scope)): + self._addresses = LIST(value) + else: + self._addresses = value + else: + self._addresses = value + return property(**locals()) + + @apply + def engagedin(): + def fget( self ): + return self._engagedin + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument engagedin is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def identifiableperson(self): + eval_identifiableperson_wr = ((EXISTS(self.identification) or EXISTS(self.familyname)) or EXISTS(self.givenname)) + if not eval_identifiableperson_wr: + raise AssertionError('Rule identifiableperson violated') + else: + return eval_identifiableperson_wr + + def validsetofnames(self): + eval_validsetofnames_wr = ((( not EXISTS(self.middlenames)) or EXISTS(self.familyname)) or EXISTS(self.givenname)) + if not eval_validsetofnames_wr: + raise AssertionError('Rule validsetofnames violated') + else: + return eval_validsetofnames_wr + + +#################### + # ENTITY ifcairterminaltype # +#################### +class ifcairterminaltype(ifcflowterminaltype): + '''Entity ifcairterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcairterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcairterminaltypeenum): + self._predefinedtype = ifcairterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcairterminaltypeenum.self.userdefined) or ((self.predefinedtype == ifcairterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcfacebound # +#################### +class ifcfacebound(ifctopologicalrepresentationitem): + '''Entity ifcfacebound definition. + + :param bound + :type bound:ifcloop + + :param orientation + :type orientation:BOOLEAN + ''' + def __init__( self , bound,orientation, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.bound = bound + self.orientation = orientation + + @apply + def bound(): + def fget( self ): + return self._bound + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bound is mantatory and can not be set to None') + if not check_type(value,ifcloop): + self._bound = ifcloop(value) + else: + self._bound = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + +#################### + # ENTITY ifcfiresuppressionterminal # +#################### +class ifcfiresuppressionterminal(ifcflowterminal): + '''Entity ifcfiresuppressionterminal definition. + + :param predefinedtype + :type predefinedtype:ifcfiresuppressionterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfiresuppressionterminaltypeenum): + self._predefinedtype = ifcfiresuppressionterminaltypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcfiresuppressionterminaltypeenum.self.userdefined)) or ((self.predefinedtype == ifcfiresuppressionterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCFIRESUPPRESSIONTERMINALTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcevaporativecooler # +#################### +class ifcevaporativecooler(ifcenergyconversiondevice): + '''Entity ifcevaporativecooler definition. + + :param predefinedtype + :type predefinedtype:ifcevaporativecoolertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcevaporativecoolertypeenum): + self._predefinedtype = ifcevaporativecoolertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcevaporativecoolertypeenum.self.userdefined)) or ((self.predefinedtype == ifcevaporativecoolertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCEVAPORATIVECOOLERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcsurfacestylelighting # +#################### +class ifcsurfacestylelighting(ifcpresentationitem): + '''Entity ifcsurfacestylelighting definition. + + :param diffusetransmissioncolour + :type diffusetransmissioncolour:ifccolourrgb + + :param diffusereflectioncolour + :type diffusereflectioncolour:ifccolourrgb + + :param transmissioncolour + :type transmissioncolour:ifccolourrgb + + :param reflectancecolour + :type reflectancecolour:ifccolourrgb + ''' + def __init__( self , diffusetransmissioncolour,diffusereflectioncolour,transmissioncolour,reflectancecolour, ): + ifcpresentationitem.__init__(self , ) + self.diffusetransmissioncolour = diffusetransmissioncolour + self.diffusereflectioncolour = diffusereflectioncolour + self.transmissioncolour = transmissioncolour + self.reflectancecolour = reflectancecolour + + @apply + def diffusetransmissioncolour(): + def fget( self ): + return self._diffusetransmissioncolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument diffusetransmissioncolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._diffusetransmissioncolour = ifccolourrgb(value) + else: + self._diffusetransmissioncolour = value + return property(**locals()) + + @apply + def diffusereflectioncolour(): + def fget( self ): + return self._diffusereflectioncolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument diffusereflectioncolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._diffusereflectioncolour = ifccolourrgb(value) + else: + self._diffusereflectioncolour = value + return property(**locals()) + + @apply + def transmissioncolour(): + def fget( self ): + return self._transmissioncolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument transmissioncolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._transmissioncolour = ifccolourrgb(value) + else: + self._transmissioncolour = value + return property(**locals()) + + @apply + def reflectancecolour(): + def fget( self ): + return self._reflectancecolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reflectancecolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._reflectancecolour = ifccolourrgb(value) + else: + self._reflectancecolour = value + return property(**locals()) + +#################### + # ENTITY ifctasktype # +#################### +class ifctasktype(ifctypeprocess): + '''Entity ifctasktype definition. + + :param predefinedtype + :type predefinedtype:ifctasktypeenum + + :param workmethod + :type workmethod:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__processtype , predefinedtype,workmethod, ): + ifctypeprocess.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__processtype , ) + self.predefinedtype = predefinedtype + self.workmethod = workmethod + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctasktypeenum): + self._predefinedtype = ifctasktypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def workmethod(): + def fget( self ): + return self._workmethod + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._workmethod = ifclabel(value) + else: + self._workmethod = value + else: + self._workmethod = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifctasktypeenum.self.userdefined) or ((self.predefinedtype == ifctasktypeenum.self.userdefined) and EXISTS(self.self.ifctypeprocess.self.processtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifctendon # +#################### +class ifctendon(ifcreinforcingelement): + '''Entity ifctendon definition. + + :param predefinedtype + :type predefinedtype:ifctendontypeenum + + :param nominaldiameter + :type nominaldiameter:ifcpositivelengthmeasure + + :param crosssectionarea + :type crosssectionarea:ifcareameasure + + :param tensionforce + :type tensionforce:ifcforcemeasure + + :param prestress + :type prestress:ifcpressuremeasure + + :param frictioncoefficient + :type frictioncoefficient:ifcnormalisedratiomeasure + + :param anchorageslip + :type anchorageslip:ifcpositivelengthmeasure + + :param mincurvatureradius + :type mincurvatureradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , predefinedtype,nominaldiameter,crosssectionarea,tensionforce,prestress,frictioncoefficient,anchorageslip,mincurvatureradius, ): + ifcreinforcingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , ) + self.predefinedtype = predefinedtype + self.nominaldiameter = nominaldiameter + self.crosssectionarea = crosssectionarea + self.tensionforce = tensionforce + self.prestress = prestress + self.frictioncoefficient = frictioncoefficient + self.anchorageslip = anchorageslip + self.mincurvatureradius = mincurvatureradius + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctendontypeenum): + self._predefinedtype = ifctendontypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def nominaldiameter(): + def fget( self ): + return self._nominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominaldiameter = ifcpositivelengthmeasure(value) + else: + self._nominaldiameter = value + else: + self._nominaldiameter = value + return property(**locals()) + + @apply + def crosssectionarea(): + def fget( self ): + return self._crosssectionarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._crosssectionarea = ifcareameasure(value) + else: + self._crosssectionarea = value + else: + self._crosssectionarea = value + return property(**locals()) + + @apply + def tensionforce(): + def fget( self ): + return self._tensionforce + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcforcemeasure): + self._tensionforce = ifcforcemeasure(value) + else: + self._tensionforce = value + else: + self._tensionforce = value + return property(**locals()) + + @apply + def prestress(): + def fget( self ): + return self._prestress + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpressuremeasure): + self._prestress = ifcpressuremeasure(value) + else: + self._prestress = value + else: + self._prestress = value + return property(**locals()) + + @apply + def frictioncoefficient(): + def fget( self ): + return self._frictioncoefficient + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._frictioncoefficient = ifcnormalisedratiomeasure(value) + else: + self._frictioncoefficient = value + else: + self._frictioncoefficient = value + return property(**locals()) + + @apply + def anchorageslip(): + def fget( self ): + return self._anchorageslip + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._anchorageslip = ifcpositivelengthmeasure(value) + else: + self._anchorageslip = value + else: + self._anchorageslip = value + return property(**locals()) + + @apply + def mincurvatureradius(): + def fget( self ): + return self._mincurvatureradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._mincurvatureradius = ifcpositivelengthmeasure(value) + else: + self._mincurvatureradius = value + else: + self._mincurvatureradius = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifctendontypeenum.self.userdefined)) or ((self.predefinedtype == ifctendontypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCTENDONTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcownerhistory # +#################### +class ifcownerhistory(BaseEntityClass): + '''Entity ifcownerhistory definition. + + :param owninguser + :type owninguser:ifcpersonandorganization + + :param owningapplication + :type owningapplication:ifcapplication + + :param state + :type state:ifcstateenum + + :param changeaction + :type changeaction:ifcchangeactionenum + + :param lastmodifieddate + :type lastmodifieddate:ifctimestamp + + :param lastmodifyinguser + :type lastmodifyinguser:ifcpersonandorganization + + :param lastmodifyingapplication + :type lastmodifyingapplication:ifcapplication + + :param creationdate + :type creationdate:ifctimestamp + ''' + def __init__( self , owninguser,owningapplication,state,changeaction,lastmodifieddate,lastmodifyinguser,lastmodifyingapplication,creationdate, ): + self.owninguser = owninguser + self.owningapplication = owningapplication + self.state = state + self.changeaction = changeaction + self.lastmodifieddate = lastmodifieddate + self.lastmodifyinguser = lastmodifyinguser + self.lastmodifyingapplication = lastmodifyingapplication + self.creationdate = creationdate + + @apply + def owninguser(): + def fget( self ): + return self._owninguser + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument owninguser is mantatory and can not be set to None') + if not check_type(value,ifcpersonandorganization): + self._owninguser = ifcpersonandorganization(value) + else: + self._owninguser = value + return property(**locals()) + + @apply + def owningapplication(): + def fget( self ): + return self._owningapplication + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument owningapplication is mantatory and can not be set to None') + if not check_type(value,ifcapplication): + self._owningapplication = ifcapplication(value) + else: + self._owningapplication = value + return property(**locals()) + + @apply + def state(): + def fget( self ): + return self._state + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstateenum): + self._state = ifcstateenum(value) + else: + self._state = value + else: + self._state = value + return property(**locals()) + + @apply + def changeaction(): + def fget( self ): + return self._changeaction + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcchangeactionenum): + self._changeaction = ifcchangeactionenum(value) + else: + self._changeaction = value + else: + self._changeaction = value + return property(**locals()) + + @apply + def lastmodifieddate(): + def fget( self ): + return self._lastmodifieddate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctimestamp): + self._lastmodifieddate = ifctimestamp(value) + else: + self._lastmodifieddate = value + else: + self._lastmodifieddate = value + return property(**locals()) + + @apply + def lastmodifyinguser(): + def fget( self ): + return self._lastmodifyinguser + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpersonandorganization): + self._lastmodifyinguser = ifcpersonandorganization(value) + else: + self._lastmodifyinguser = value + else: + self._lastmodifyinguser = value + return property(**locals()) + + @apply + def lastmodifyingapplication(): + def fget( self ): + return self._lastmodifyingapplication + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcapplication): + self._lastmodifyingapplication = ifcapplication(value) + else: + self._lastmodifyingapplication = value + else: + self._lastmodifyingapplication = value + return property(**locals()) + + @apply + def creationdate(): + def fget( self ): + return self._creationdate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument creationdate is mantatory and can not be set to None') + if not check_type(value,ifctimestamp): + self._creationdate = ifctimestamp(value) + else: + self._creationdate = value + return property(**locals()) + def correctchangeaction(self): + eval_correctchangeaction_wr = ((EXISTS(self.lastmodifieddate) or (( not EXISTS(self.lastmodifieddate)) and ( not EXISTS(self.changeaction)))) or ((( not EXISTS(self.lastmodifieddate)) and EXISTS(self.changeaction)) and ((self.changeaction == ifcchangeactionenum.self.notdefined) or (self.changeaction == ifcchangeactionenum.self.nochange)))) + if not eval_correctchangeaction_wr: + raise AssertionError('Rule correctchangeaction violated') + else: + return eval_correctchangeaction_wr + + +#################### + # ENTITY ifcsurfacestylewithtextures # +#################### +class ifcsurfacestylewithtextures(ifcpresentationitem): + '''Entity ifcsurfacestylewithtextures definition. + + :param textures + :type textures:LIST(1,None,'ifcsurfacetexture', scope = schema_scope) + ''' + def __init__( self , textures, ): + ifcpresentationitem.__init__(self , ) + self.textures = textures + + @apply + def textures(): + def fget( self ): + return self._textures + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument textures is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcsurfacetexture', scope = schema_scope)): + self._textures = LIST(value) + else: + self._textures = value + return property(**locals()) + +#################### + # ENTITY ifcpipefitting # +#################### +class ifcpipefitting(ifcflowfitting): + '''Entity ifcpipefitting definition. + + :param predefinedtype + :type predefinedtype:ifcpipefittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowfitting.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpipefittingtypeenum): + self._predefinedtype = ifcpipefittingtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcpipefittingtypeenum.self.userdefined)) or ((self.predefinedtype == ifcpipefittingtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCPIPEFITTINGTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcproject # +#################### +class ifcproject(ifccontext): + '''Entity ifcproject definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__longname , inherited6__phase , inherited7__representationcontexts , inherited8__unitsincontext , ): + ifccontext.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__longname , inherited6__phase , inherited7__representationcontexts , inherited8__unitsincontext , ) + def hasname(self): + eval_hasname_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_hasname_wr: + raise AssertionError('Rule hasname violated') + else: + return eval_hasname_wr + + def correctcontext(self): + eval_correctcontext_wr = (( not EXISTS(self.self.ifccontext.self.representationcontexts)) or (SIZEOF(None) == 0)) + if not eval_correctcontext_wr: + raise AssertionError('Rule correctcontext violated') + else: + return eval_correctcontext_wr + + def nodecomposition(self): + eval_nodecomposition_wr = (SIZEOF(self.self.ifcobjectdefinition.self.decomposes) == 0) + if not eval_nodecomposition_wr: + raise AssertionError('Rule nodecomposition violated') + else: + return eval_nodecomposition_wr + + def hasownerhistory(self): + eval_hasownerhistory_wr = EXISTS(self.self.ifcroot.self.ownerhistory) + if not eval_hasownerhistory_wr: + raise AssertionError('Rule hasownerhistory violated') + else: + return eval_hasownerhistory_wr + + +#################### + # ENTITY ifccolumnstandardcase # +#################### +class ifccolumnstandardcase(ifccolumn): + '''Entity ifccolumnstandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ): + ifccolumn.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ) + def hasmaterialprofilesetusage(self): + eval_hasmaterialprofilesetusage_wr = (SIZEOF(None) == 1) + if not eval_hasmaterialprofilesetusage_wr: + raise AssertionError('Rule hasmaterialprofilesetusage violated') + else: + return eval_hasmaterialprofilesetusage_wr + + +#################### + # ENTITY ifcflowstoragedevicetype # +#################### +class ifcflowstoragedevicetype(ifcdistributionflowelementtype): + '''Entity ifcflowstoragedevicetype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcelectricflowstoragedevicetype # +#################### +class ifcelectricflowstoragedevicetype(ifcflowstoragedevicetype): + '''Entity ifcelectricflowstoragedevicetype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricflowstoragedevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowstoragedevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricflowstoragedevicetypeenum): + self._predefinedtype = ifcelectricflowstoragedevicetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcelectricflowstoragedevicetypeenum.self.userdefined) or ((self.predefinedtype == ifcelectricflowstoragedevicetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcplane # +#################### +class ifcplane(ifcelementarysurface): + '''Entity ifcplane definition. + ''' + def __init__( self , inherited0__position , ): + ifcelementarysurface.__init__(self , inherited0__position , ) + +#################### + # ENTITY ifcstructuralloadgroup # +#################### +class ifcstructuralloadgroup(ifcgroup): + '''Entity ifcstructuralloadgroup definition. + + :param predefinedtype + :type predefinedtype:ifcloadgrouptypeenum + + :param actiontype + :type actiontype:ifcactiontypeenum + + :param actionsource + :type actionsource:ifcactionsourcetypeenum + + :param coefficient + :type coefficient:ifcratiomeasure + + :param purpose + :type purpose:ifclabel + + :param sourceofresultgroup + :type sourceofresultgroup:SET(0,1,'ifcstructuralresultgroup', scope = schema_scope) + + :param loadgroupfor + :type loadgroupfor:SET(0,None,'ifcstructuralanalysismodel', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , predefinedtype,actiontype,actionsource,coefficient,purpose, ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.predefinedtype = predefinedtype + self.actiontype = actiontype + self.actionsource = actionsource + self.coefficient = coefficient + self.purpose = purpose + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcloadgrouptypeenum): + self._predefinedtype = ifcloadgrouptypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def actiontype(): + def fget( self ): + return self._actiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actiontype is mantatory and can not be set to None') + if not check_type(value,ifcactiontypeenum): + self._actiontype = ifcactiontypeenum(value) + else: + self._actiontype = value + return property(**locals()) + + @apply + def actionsource(): + def fget( self ): + return self._actionsource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument actionsource is mantatory and can not be set to None') + if not check_type(value,ifcactionsourcetypeenum): + self._actionsource = ifcactionsourcetypeenum(value) + else: + self._actionsource = value + return property(**locals()) + + @apply + def coefficient(): + def fget( self ): + return self._coefficient + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcratiomeasure): + self._coefficient = ifcratiomeasure(value) + else: + self._coefficient = value + else: + self._coefficient = value + return property(**locals()) + + @apply + def purpose(): + def fget( self ): + return self._purpose + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._purpose = ifclabel(value) + else: + self._purpose = value + else: + self._purpose = value + return property(**locals()) + + @apply + def sourceofresultgroup(): + def fget( self ): + return self._sourceofresultgroup + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument sourceofresultgroup is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def loadgroupfor(): + def fget( self ): + return self._loadgroupfor + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument loadgroupfor is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def hasobjecttype(self): + eval_hasobjecttype_wr = ((((self.predefinedtype != ifcloadgrouptypeenum.self.userdefined) and (self.actiontype != ifcactiontypeenum.self.userdefined)) and (self.actionsource != ifcactionsourcetypeenum.self.userdefined)) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + +#################### + # ENTITY ifcstructuralloadcase # +#################### +class ifcstructuralloadcase(ifcstructuralloadgroup): + '''Entity ifcstructuralloadcase definition. + + :param selfweightcoefficients + :type selfweightcoefficients:LIST(3,3,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__predefinedtype , inherited6__actiontype , inherited7__actionsource , inherited8__coefficient , inherited9__purpose , selfweightcoefficients, ): + ifcstructuralloadgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__predefinedtype , inherited6__actiontype , inherited7__actionsource , inherited8__coefficient , inherited9__purpose , ) + self.selfweightcoefficients = selfweightcoefficients + + @apply + def selfweightcoefficients(): + def fget( self ): + return self._selfweightcoefficients + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(3,3,'REAL', scope = schema_scope)): + self._selfweightcoefficients = LIST(value) + else: + self._selfweightcoefficients = value + else: + self._selfweightcoefficients = value + return property(**locals()) + def isloadcasepredefinedtype(self): + eval_isloadcasepredefinedtype_wr = (self.self.ifcstructuralloadgroup.self.predefinedtype == ifcloadgrouptypeenum.self.load_case) + if not eval_isloadcasepredefinedtype_wr: + raise AssertionError('Rule isloadcasepredefinedtype violated') + else: + return eval_isloadcasepredefinedtype_wr + + +#################### + # ENTITY ifccolourspecification # +#################### +class ifccolourspecification(ifcpresentationitem): + '''Entity ifccolourspecification definition. + + :param name + :type name:ifclabel + ''' + def __init__( self , name, ): + ifcpresentationitem.__init__(self , ) + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + +#################### + # ENTITY ifccolourrgb # +#################### +class ifccolourrgb(ifccolourspecification): + '''Entity ifccolourrgb definition. + + :param red + :type red:ifcnormalisedratiomeasure + + :param green + :type green:ifcnormalisedratiomeasure + + :param blue + :type blue:ifcnormalisedratiomeasure + ''' + def __init__( self , inherited0__name , red,green,blue, ): + ifccolourspecification.__init__(self , inherited0__name , ) + self.red = red + self.green = green + self.blue = blue + + @apply + def red(): + def fget( self ): + return self._red + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument red is mantatory and can not be set to None') + if not check_type(value,ifcnormalisedratiomeasure): + self._red = ifcnormalisedratiomeasure(value) + else: + self._red = value + return property(**locals()) + + @apply + def green(): + def fget( self ): + return self._green + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument green is mantatory and can not be set to None') + if not check_type(value,ifcnormalisedratiomeasure): + self._green = ifcnormalisedratiomeasure(value) + else: + self._green = value + return property(**locals()) + + @apply + def blue(): + def fget( self ): + return self._blue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument blue is mantatory and can not be set to None') + if not check_type(value,ifcnormalisedratiomeasure): + self._blue = ifcnormalisedratiomeasure(value) + else: + self._blue = value + return property(**locals()) + +#################### + # ENTITY ifcductsilencer # +#################### +class ifcductsilencer(ifcflowtreatmentdevice): + '''Entity ifcductsilencer definition. + + :param predefinedtype + :type predefinedtype:ifcductsilencertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowtreatmentdevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcductsilencertypeenum): + self._predefinedtype = ifcductsilencertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcductsilencertypeenum.self.userdefined)) or ((self.predefinedtype == ifcductsilencertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCDUCTSILENCERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcwasteterminal # +#################### +class ifcwasteterminal(ifcflowterminal): + '''Entity ifcwasteterminal definition. + + :param predefinedtype + :type predefinedtype:ifcwasteterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcwasteterminaltypeenum): + self._predefinedtype = ifcwasteterminaltypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcwasteterminaltypeenum.self.userdefined)) or ((self.predefinedtype == ifcwasteterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCWASTETERMINALTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifccablefitting # +#################### +class ifccablefitting(ifcflowfitting): + '''Entity ifccablefitting definition. + + :param predefinedtype + :type predefinedtype:ifccablefittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowfitting.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccablefittingtypeenum): + self._predefinedtype = ifccablefittingtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccablefittingtypeenum.self.userdefined)) or ((self.predefinedtype == ifccablefittingtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCABLEFITTINGTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcreinforcingbar # +#################### +class ifcreinforcingbar(ifcreinforcingelement): + '''Entity ifcreinforcingbar definition. + + :param nominaldiameter + :type nominaldiameter:ifcpositivelengthmeasure + + :param crosssectionarea + :type crosssectionarea:ifcareameasure + + :param barlength + :type barlength:ifcpositivelengthmeasure + + :param predefinedtype + :type predefinedtype:ifcreinforcingbartypeenum + + :param barsurface + :type barsurface:ifcreinforcingbarsurfaceenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , nominaldiameter,crosssectionarea,barlength,predefinedtype,barsurface, ): + ifcreinforcingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , ) + self.nominaldiameter = nominaldiameter + self.crosssectionarea = crosssectionarea + self.barlength = barlength + self.predefinedtype = predefinedtype + self.barsurface = barsurface + + @apply + def nominaldiameter(): + def fget( self ): + return self._nominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominaldiameter = ifcpositivelengthmeasure(value) + else: + self._nominaldiameter = value + else: + self._nominaldiameter = value + return property(**locals()) + + @apply + def crosssectionarea(): + def fget( self ): + return self._crosssectionarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._crosssectionarea = ifcareameasure(value) + else: + self._crosssectionarea = value + else: + self._crosssectionarea = value + return property(**locals()) + + @apply + def barlength(): + def fget( self ): + return self._barlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._barlength = ifcpositivelengthmeasure(value) + else: + self._barlength = value + else: + self._barlength = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreinforcingbartypeenum): + self._predefinedtype = ifcreinforcingbartypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def barsurface(): + def fget( self ): + return self._barsurface + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreinforcingbarsurfaceenum): + self._barsurface = ifcreinforcingbarsurfaceenum(value) + else: + self._barsurface = value + else: + self._barsurface = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcreinforcingbartypeenum.self.userdefined)) or ((self.predefinedtype == ifcreinforcingbartypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCREINFORCINGBARTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcunitaryequipment # +#################### +class ifcunitaryequipment(ifcenergyconversiondevice): + '''Entity ifcunitaryequipment definition. + + :param predefinedtype + :type predefinedtype:ifcunitaryequipmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunitaryequipmenttypeenum): + self._predefinedtype = ifcunitaryequipmenttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcunitaryequipmenttypeenum.self.userdefined)) or ((self.predefinedtype == ifcunitaryequipmenttypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCUNITARYEQUIPMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcpermit # +#################### +class ifcpermit(ifccontrol): + '''Entity ifcpermit definition. + + :param predefinedtype + :type predefinedtype:ifcpermittypeenum + + :param status + :type status:ifclabel + + :param longdescription + :type longdescription:ifctext + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , predefinedtype,status,longdescription, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , ) + self.predefinedtype = predefinedtype + self.status = status + self.longdescription = longdescription + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpermittypeenum): + self._predefinedtype = ifcpermittypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._status = ifclabel(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def longdescription(): + def fget( self ): + return self._longdescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._longdescription = ifctext(value) + else: + self._longdescription = value + else: + self._longdescription = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacestyleshading # +#################### +class ifcsurfacestyleshading(ifcpresentationitem): + '''Entity ifcsurfacestyleshading definition. + + :param surfacecolour + :type surfacecolour:ifccolourrgb + ''' + def __init__( self , surfacecolour, ): + ifcpresentationitem.__init__(self , ) + self.surfacecolour = surfacecolour + + @apply + def surfacecolour(): + def fget( self ): + return self._surfacecolour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument surfacecolour is mantatory and can not be set to None') + if not check_type(value,ifccolourrgb): + self._surfacecolour = ifccolourrgb(value) + else: + self._surfacecolour = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacestylerendering # +#################### +class ifcsurfacestylerendering(ifcsurfacestyleshading): + '''Entity ifcsurfacestylerendering definition. + + :param transparency + :type transparency:ifcnormalisedratiomeasure + + :param diffusecolour + :type diffusecolour:ifccolourorfactor + + :param transmissioncolour + :type transmissioncolour:ifccolourorfactor + + :param diffusetransmissioncolour + :type diffusetransmissioncolour:ifccolourorfactor + + :param reflectioncolour + :type reflectioncolour:ifccolourorfactor + + :param specularcolour + :type specularcolour:ifccolourorfactor + + :param specularhighlight + :type specularhighlight:ifcspecularhighlightselect + + :param reflectancemethod + :type reflectancemethod:ifcreflectancemethodenum + ''' + def __init__( self , inherited0__surfacecolour , transparency,diffusecolour,transmissioncolour,diffusetransmissioncolour,reflectioncolour,specularcolour,specularhighlight,reflectancemethod, ): + ifcsurfacestyleshading.__init__(self , inherited0__surfacecolour , ) + self.transparency = transparency + self.diffusecolour = diffusecolour + self.transmissioncolour = transmissioncolour + self.diffusetransmissioncolour = diffusetransmissioncolour + self.reflectioncolour = reflectioncolour + self.specularcolour = specularcolour + self.specularhighlight = specularhighlight + self.reflectancemethod = reflectancemethod + + @apply + def transparency(): + def fget( self ): + return self._transparency + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnormalisedratiomeasure): + self._transparency = ifcnormalisedratiomeasure(value) + else: + self._transparency = value + else: + self._transparency = value + return property(**locals()) + + @apply + def diffusecolour(): + def fget( self ): + return self._diffusecolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._diffusecolour = ifccolourorfactor(value) + else: + self._diffusecolour = value + else: + self._diffusecolour = value + return property(**locals()) + + @apply + def transmissioncolour(): + def fget( self ): + return self._transmissioncolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._transmissioncolour = ifccolourorfactor(value) + else: + self._transmissioncolour = value + else: + self._transmissioncolour = value + return property(**locals()) + + @apply + def diffusetransmissioncolour(): + def fget( self ): + return self._diffusetransmissioncolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._diffusetransmissioncolour = ifccolourorfactor(value) + else: + self._diffusetransmissioncolour = value + else: + self._diffusetransmissioncolour = value + return property(**locals()) + + @apply + def reflectioncolour(): + def fget( self ): + return self._reflectioncolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._reflectioncolour = ifccolourorfactor(value) + else: + self._reflectioncolour = value + else: + self._reflectioncolour = value + return property(**locals()) + + @apply + def specularcolour(): + def fget( self ): + return self._specularcolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourorfactor): + self._specularcolour = ifccolourorfactor(value) + else: + self._specularcolour = value + else: + self._specularcolour = value + return property(**locals()) + + @apply + def specularhighlight(): + def fget( self ): + return self._specularhighlight + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcspecularhighlightselect): + self._specularhighlight = ifcspecularhighlightselect(value) + else: + self._specularhighlight = value + else: + self._specularhighlight = value + return property(**locals()) + + @apply + def reflectancemethod(): + def fget( self ): + return self._reflectancemethod + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reflectancemethod is mantatory and can not be set to None') + if not check_type(value,ifcreflectancemethodenum): + self._reflectancemethod = ifcreflectancemethodenum(value) + else: + self._reflectancemethod = value + return property(**locals()) + +#################### + # ENTITY ifcelectrictimecontroltype # +#################### +class ifcelectrictimecontroltype(ifcflowcontrollertype): + '''Entity ifcelectrictimecontroltype definition. + + :param predefinedtype + :type predefinedtype:ifcelectrictimecontroltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectrictimecontroltypeenum): + self._predefinedtype = ifcelectrictimecontroltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcelectrictimecontroltypeenum.self.userdefined) or ((self.predefinedtype == ifcelectrictimecontroltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccoordinateoperation # +#################### +class ifccoordinateoperation(BaseEntityClass): + '''Entity ifccoordinateoperation definition. + + :param sourcecrs + :type sourcecrs:ifccoordinatereferencesystemselect + + :param targetcrs + :type targetcrs:ifccoordinatereferencesystem + ''' + def __init__( self , sourcecrs,targetcrs, ): + self.sourcecrs = sourcecrs + self.targetcrs = targetcrs + + @apply + def sourcecrs(): + def fget( self ): + return self._sourcecrs + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sourcecrs is mantatory and can not be set to None') + if not check_type(value,ifccoordinatereferencesystemselect): + self._sourcecrs = ifccoordinatereferencesystemselect(value) + else: + self._sourcecrs = value + return property(**locals()) + + @apply + def targetcrs(): + def fget( self ): + return self._targetcrs + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument targetcrs is mantatory and can not be set to None') + if not check_type(value,ifccoordinatereferencesystem): + self._targetcrs = ifccoordinatereferencesystem(value) + else: + self._targetcrs = value + return property(**locals()) + +#################### + # ENTITY ifcmapconversion # +#################### +class ifcmapconversion(ifccoordinateoperation): + '''Entity ifcmapconversion definition. + + :param eastings + :type eastings:ifclengthmeasure + + :param northings + :type northings:ifclengthmeasure + + :param orthogonalheight + :type orthogonalheight:ifclengthmeasure + + :param xaxisabscissa + :type xaxisabscissa:ifcreal + + :param xaxisordinate + :type xaxisordinate:ifcreal + + :param scale + :type scale:ifcreal + ''' + def __init__( self , inherited0__sourcecrs , inherited1__targetcrs , eastings,northings,orthogonalheight,xaxisabscissa,xaxisordinate,scale, ): + ifccoordinateoperation.__init__(self , inherited0__sourcecrs , inherited1__targetcrs , ) + self.eastings = eastings + self.northings = northings + self.orthogonalheight = orthogonalheight + self.xaxisabscissa = xaxisabscissa + self.xaxisordinate = xaxisordinate + self.scale = scale + + @apply + def eastings(): + def fget( self ): + return self._eastings + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument eastings is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._eastings = ifclengthmeasure(value) + else: + self._eastings = value + return property(**locals()) + + @apply + def northings(): + def fget( self ): + return self._northings + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument northings is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._northings = ifclengthmeasure(value) + else: + self._northings = value + return property(**locals()) + + @apply + def orthogonalheight(): + def fget( self ): + return self._orthogonalheight + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orthogonalheight is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._orthogonalheight = ifclengthmeasure(value) + else: + self._orthogonalheight = value + return property(**locals()) + + @apply + def xaxisabscissa(): + def fget( self ): + return self._xaxisabscissa + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreal): + self._xaxisabscissa = ifcreal(value) + else: + self._xaxisabscissa = value + else: + self._xaxisabscissa = value + return property(**locals()) + + @apply + def xaxisordinate(): + def fget( self ): + return self._xaxisordinate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreal): + self._xaxisordinate = ifcreal(value) + else: + self._xaxisordinate = value + else: + self._xaxisordinate = value + return property(**locals()) + + @apply + def scale(): + def fget( self ): + return self._scale + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreal): + self._scale = ifcreal(value) + else: + self._scale = value + else: + self._scale = value + return property(**locals()) + +#################### + # ENTITY ifcstackterminaltype # +#################### +class ifcstackterminaltype(ifcflowterminaltype): + '''Entity ifcstackterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcstackterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstackterminaltypeenum): + self._predefinedtype = ifcstackterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcstackterminaltypeenum.self.userdefined) or ((self.predefinedtype == ifcstackterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifctank # +#################### +class ifctank(ifcflowstoragedevice): + '''Entity ifctank definition. + + :param predefinedtype + :type predefinedtype:ifctanktypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowstoragedevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctanktypeenum): + self._predefinedtype = ifctanktypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifctanktypeenum.self.userdefined)) or ((self.predefinedtype == ifctanktypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCTANKTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifctasktime # +#################### +class ifctasktime(ifcschedulingtime): + '''Entity ifctasktime definition. + + :param durationtype + :type durationtype:ifctaskdurationenum + + :param scheduleduration + :type scheduleduration:ifcduration + + :param schedulestart + :type schedulestart:ifcdatetime + + :param schedulefinish + :type schedulefinish:ifcdatetime + + :param earlystart + :type earlystart:ifcdatetime + + :param earlyfinish + :type earlyfinish:ifcdatetime + + :param latestart + :type latestart:ifcdatetime + + :param latefinish + :type latefinish:ifcdatetime + + :param freefloat + :type freefloat:ifcduration + + :param totalfloat + :type totalfloat:ifcduration + + :param iscritical + :type iscritical:BOOLEAN + + :param statustime + :type statustime:ifcdatetime + + :param actualduration + :type actualduration:ifcduration + + :param actualstart + :type actualstart:ifcdatetime + + :param actualfinish + :type actualfinish:ifcdatetime + + :param remainingtime + :type remainingtime:ifcduration + + :param completion + :type completion:ifcpositiveratiomeasure + ''' + def __init__( self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , durationtype,scheduleduration,schedulestart,schedulefinish,earlystart,earlyfinish,latestart,latefinish,freefloat,totalfloat,iscritical,statustime,actualduration,actualstart,actualfinish,remainingtime,completion, ): + ifcschedulingtime.__init__(self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , ) + self.durationtype = durationtype + self.scheduleduration = scheduleduration + self.schedulestart = schedulestart + self.schedulefinish = schedulefinish + self.earlystart = earlystart + self.earlyfinish = earlyfinish + self.latestart = latestart + self.latefinish = latefinish + self.freefloat = freefloat + self.totalfloat = totalfloat + self.iscritical = iscritical + self.statustime = statustime + self.actualduration = actualduration + self.actualstart = actualstart + self.actualfinish = actualfinish + self.remainingtime = remainingtime + self.completion = completion + + @apply + def durationtype(): + def fget( self ): + return self._durationtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctaskdurationenum): + self._durationtype = ifctaskdurationenum(value) + else: + self._durationtype = value + else: + self._durationtype = value + return property(**locals()) + + @apply + def scheduleduration(): + def fget( self ): + return self._scheduleduration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._scheduleduration = ifcduration(value) + else: + self._scheduleduration = value + else: + self._scheduleduration = value + return property(**locals()) + + @apply + def schedulestart(): + def fget( self ): + return self._schedulestart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._schedulestart = ifcdatetime(value) + else: + self._schedulestart = value + else: + self._schedulestart = value + return property(**locals()) + + @apply + def schedulefinish(): + def fget( self ): + return self._schedulefinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._schedulefinish = ifcdatetime(value) + else: + self._schedulefinish = value + else: + self._schedulefinish = value + return property(**locals()) + + @apply + def earlystart(): + def fget( self ): + return self._earlystart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._earlystart = ifcdatetime(value) + else: + self._earlystart = value + else: + self._earlystart = value + return property(**locals()) + + @apply + def earlyfinish(): + def fget( self ): + return self._earlyfinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._earlyfinish = ifcdatetime(value) + else: + self._earlyfinish = value + else: + self._earlyfinish = value + return property(**locals()) + + @apply + def latestart(): + def fget( self ): + return self._latestart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._latestart = ifcdatetime(value) + else: + self._latestart = value + else: + self._latestart = value + return property(**locals()) + + @apply + def latefinish(): + def fget( self ): + return self._latefinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._latefinish = ifcdatetime(value) + else: + self._latefinish = value + else: + self._latefinish = value + return property(**locals()) + + @apply + def freefloat(): + def fget( self ): + return self._freefloat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._freefloat = ifcduration(value) + else: + self._freefloat = value + else: + self._freefloat = value + return property(**locals()) + + @apply + def totalfloat(): + def fget( self ): + return self._totalfloat + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._totalfloat = ifcduration(value) + else: + self._totalfloat = value + else: + self._totalfloat = value + return property(**locals()) + + @apply + def iscritical(): + def fget( self ): + return self._iscritical + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._iscritical = BOOLEAN(value) + else: + self._iscritical = value + else: + self._iscritical = value + return property(**locals()) + + @apply + def statustime(): + def fget( self ): + return self._statustime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._statustime = ifcdatetime(value) + else: + self._statustime = value + else: + self._statustime = value + return property(**locals()) + + @apply + def actualduration(): + def fget( self ): + return self._actualduration + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._actualduration = ifcduration(value) + else: + self._actualduration = value + else: + self._actualduration = value + return property(**locals()) + + @apply + def actualstart(): + def fget( self ): + return self._actualstart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._actualstart = ifcdatetime(value) + else: + self._actualstart = value + else: + self._actualstart = value + return property(**locals()) + + @apply + def actualfinish(): + def fget( self ): + return self._actualfinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._actualfinish = ifcdatetime(value) + else: + self._actualfinish = value + else: + self._actualfinish = value + return property(**locals()) + + @apply + def remainingtime(): + def fget( self ): + return self._remainingtime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._remainingtime = ifcduration(value) + else: + self._remainingtime = value + else: + self._remainingtime = value + return property(**locals()) + + @apply + def completion(): + def fget( self ): + return self._completion + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._completion = ifcpositiveratiomeasure(value) + else: + self._completion = value + else: + self._completion = value + return property(**locals()) + +#################### + # ENTITY ifctasktimerecurring # +#################### +class ifctasktimerecurring(ifctasktime): + '''Entity ifctasktimerecurring definition. + + :param recurrance + :type recurrance:ifcrecurrencepattern + ''' + def __init__( self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , inherited3__durationtype , inherited4__scheduleduration , inherited5__schedulestart , inherited6__schedulefinish , inherited7__earlystart , inherited8__earlyfinish , inherited9__latestart , inherited10__latefinish , inherited11__freefloat , inherited12__totalfloat , inherited13__iscritical , inherited14__statustime , inherited15__actualduration , inherited16__actualstart , inherited17__actualfinish , inherited18__remainingtime , inherited19__completion , recurrance, ): + ifctasktime.__init__(self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , inherited3__durationtype , inherited4__scheduleduration , inherited5__schedulestart , inherited6__schedulefinish , inherited7__earlystart , inherited8__earlyfinish , inherited9__latestart , inherited10__latefinish , inherited11__freefloat , inherited12__totalfloat , inherited13__iscritical , inherited14__statustime , inherited15__actualduration , inherited16__actualstart , inherited17__actualfinish , inherited18__remainingtime , inherited19__completion , ) + self.recurrance = recurrance + + @apply + def recurrance(): + def fget( self ): + return self._recurrance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument recurrance is mantatory and can not be set to None') + if not check_type(value,ifcrecurrencepattern): + self._recurrance = ifcrecurrencepattern(value) + else: + self._recurrance = value + return property(**locals()) + +#################### + # ENTITY ifcport # +#################### +class ifcport(ifcproduct): + '''Entity ifcport definition. + + :param containedin + :type containedin:SET(0,1,'ifcrelconnectsporttoelement', scope = schema_scope) + + :param connectedfrom + :type connectedfrom:SET(0,1,'ifcrelconnectsports', scope = schema_scope) + + :param connectedto + :type connectedto:SET(0,1,'ifcrelconnectsports', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + + @apply + def containedin(): + def fget( self ): + return self._containedin + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containedin is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def connectedfrom(): + def fget( self ): + return self._connectedfrom + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedfrom is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def connectedto(): + def fget( self ): + return self._connectedto + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument connectedto is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcprotectivedevicetrippingunit # +#################### +class ifcprotectivedevicetrippingunit(ifcdistributioncontrolelement): + '''Entity ifcprotectivedevicetrippingunit definition. + + :param predefinedtype + :type predefinedtype:ifcprotectivedevicetrippingunittypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcdistributioncontrolelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcprotectivedevicetrippingunittypeenum): + self._predefinedtype = ifcprotectivedevicetrippingunittypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcprotectivedevicetrippingunittypeenum.self.userdefined)) or ((self.predefinedtype == ifcprotectivedevicetrippingunittypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCPROTECTIVEDEVICETRIPPINGUNITTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifctendonanchortype # +#################### +class ifctendonanchortype(ifcreinforcingelementtype): + '''Entity ifctendonanchortype definition. + + :param predefinedtype + :type predefinedtype:ifctendonanchortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcreinforcingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctendonanchortypeenum): + self._predefinedtype = ifctendonanchortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifctendonanchortypeenum.self.userdefined) or ((self.predefinedtype == ifctendonanchortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcairtoairheatrecovery # +#################### +class ifcairtoairheatrecovery(ifcenergyconversiondevice): + '''Entity ifcairtoairheatrecovery definition. + + :param predefinedtype + :type predefinedtype:ifcairtoairheatrecoverytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcairtoairheatrecoverytypeenum): + self._predefinedtype = ifcairtoairheatrecoverytypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcairtoairheatrecoverytypeenum.self.userdefined)) or ((self.predefinedtype == ifcairtoairheatrecoverytypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCAIRTOAIRHEATRECOVERYTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcchillertype # +#################### +class ifcchillertype(ifcenergyconversiondevicetype): + '''Entity ifcchillertype definition. + + :param predefinedtype + :type predefinedtype:ifcchillertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcchillertypeenum): + self._predefinedtype = ifcchillertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcchillertypeenum.self.userdefined) or ((self.predefinedtype == ifcchillertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccooledbeamtype # +#################### +class ifccooledbeamtype(ifcenergyconversiondevicetype): + '''Entity ifccooledbeamtype definition. + + :param predefinedtype + :type predefinedtype:ifccooledbeamtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccooledbeamtypeenum): + self._predefinedtype = ifccooledbeamtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccooledbeamtypeenum.self.userdefined) or ((self.predefinedtype == ifccooledbeamtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpersonandorganization # +#################### +class ifcpersonandorganization(BaseEntityClass): + '''Entity ifcpersonandorganization definition. + + :param theperson + :type theperson:ifcperson + + :param theorganization + :type theorganization:ifcorganization + + :param roles + :type roles:LIST(1,None,'ifcactorrole', scope = schema_scope) + ''' + def __init__( self , theperson,theorganization,roles, ): + self.theperson = theperson + self.theorganization = theorganization + self.roles = roles + + @apply + def theperson(): + def fget( self ): + return self._theperson + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument theperson is mantatory and can not be set to None') + if not check_type(value,ifcperson): + self._theperson = ifcperson(value) + else: + self._theperson = value + return property(**locals()) + + @apply + def theorganization(): + def fget( self ): + return self._theorganization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument theorganization is mantatory and can not be set to None') + if not check_type(value,ifcorganization): + self._theorganization = ifcorganization(value) + else: + self._theorganization = value + return property(**locals()) + + @apply + def roles(): + def fget( self ): + return self._roles + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcactorrole', scope = schema_scope)): + self._roles = LIST(value) + else: + self._roles = value + else: + self._roles = value + return property(**locals()) + +#################### + # ENTITY ifcpostaladdress # +#################### +class ifcpostaladdress(ifcaddress): + '''Entity ifcpostaladdress definition. + + :param internallocation + :type internallocation:ifclabel + + :param addresslines + :type addresslines:LIST(1,None,'STRING', scope = schema_scope) + + :param postalbox + :type postalbox:ifclabel + + :param town + :type town:ifclabel + + :param region + :type region:ifclabel + + :param postalcode + :type postalcode:ifclabel + + :param country + :type country:ifclabel + ''' + def __init__( self , inherited0__purpose , inherited1__description , inherited2__userdefinedpurpose , internallocation,addresslines,postalbox,town,region,postalcode,country, ): + ifcaddress.__init__(self , inherited0__purpose , inherited1__description , inherited2__userdefinedpurpose , ) + self.internallocation = internallocation + self.addresslines = addresslines + self.postalbox = postalbox + self.town = town + self.region = region + self.postalcode = postalcode + self.country = country + + @apply + def internallocation(): + def fget( self ): + return self._internallocation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._internallocation = ifclabel(value) + else: + self._internallocation = value + else: + self._internallocation = value + return property(**locals()) + + @apply + def addresslines(): + def fget( self ): + return self._addresslines + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'STRING', scope = schema_scope)): + self._addresslines = LIST(value) + else: + self._addresslines = value + else: + self._addresslines = value + return property(**locals()) + + @apply + def postalbox(): + def fget( self ): + return self._postalbox + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._postalbox = ifclabel(value) + else: + self._postalbox = value + else: + self._postalbox = value + return property(**locals()) + + @apply + def town(): + def fget( self ): + return self._town + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._town = ifclabel(value) + else: + self._town = value + else: + self._town = value + return property(**locals()) + + @apply + def region(): + def fget( self ): + return self._region + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._region = ifclabel(value) + else: + self._region = value + else: + self._region = value + return property(**locals()) + + @apply + def postalcode(): + def fget( self ): + return self._postalcode + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._postalcode = ifclabel(value) + else: + self._postalcode = value + else: + self._postalcode = value + return property(**locals()) + + @apply + def country(): + def fget( self ): + return self._country + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._country = ifclabel(value) + else: + self._country = value + else: + self._country = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((((((EXISTS(self.internallocation) or EXISTS(self.addresslines)) or EXISTS(self.postalbox)) or EXISTS(self.postalcode)) or EXISTS(self.town)) or EXISTS(self.region)) or EXISTS(self.country)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifctimeperiod # +#################### +class ifctimeperiod(BaseEntityClass): + '''Entity ifctimeperiod definition. + + :param starttime + :type starttime:ifctime + + :param endtime + :type endtime:ifctime + ''' + def __init__( self , starttime,endtime, ): + self.starttime = starttime + self.endtime = endtime + + @apply + def starttime(): + def fget( self ): + return self._starttime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument starttime is mantatory and can not be set to None') + if not check_type(value,ifctime): + self._starttime = ifctime(value) + else: + self._starttime = value + return property(**locals()) + + @apply + def endtime(): + def fget( self ): + return self._endtime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument endtime is mantatory and can not be set to None') + if not check_type(value,ifctime): + self._endtime = ifctime(value) + else: + self._endtime = value + return property(**locals()) + +#################### + # ENTITY ifcmappeditem # +#################### +class ifcmappeditem(ifcrepresentationitem): + '''Entity ifcmappeditem definition. + + :param mappingsource + :type mappingsource:ifcrepresentationmap + + :param mappingtarget + :type mappingtarget:ifccartesiantransformationoperator + ''' + def __init__( self , mappingsource,mappingtarget, ): + ifcrepresentationitem.__init__(self , ) + self.mappingsource = mappingsource + self.mappingtarget = mappingtarget + + @apply + def mappingsource(): + def fget( self ): + return self._mappingsource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappingsource is mantatory and can not be set to None') + if not check_type(value,ifcrepresentationmap): + self._mappingsource = ifcrepresentationmap(value) + else: + self._mappingsource = value + return property(**locals()) + + @apply + def mappingtarget(): + def fget( self ): + return self._mappingtarget + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappingtarget is mantatory and can not be set to None') + if not check_type(value,ifccartesiantransformationoperator): + self._mappingtarget = ifccartesiantransformationoperator(value) + else: + self._mappingtarget = value + return property(**locals()) + +#################### + # ENTITY ifcoutlettype # +#################### +class ifcoutlettype(ifcflowterminaltype): + '''Entity ifcoutlettype definition. + + :param predefinedtype + :type predefinedtype:ifcoutlettypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcoutlettypeenum): + self._predefinedtype = ifcoutlettypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcoutlettypeenum.self.userdefined) or ((self.predefinedtype == ifcoutlettypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcslabstandardcase # +#################### +class ifcslabstandardcase(ifcslab): + '''Entity ifcslabstandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ): + ifcslab.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ) + def hasmateriallayersetusage(self): + eval_hasmateriallayersetusage_wr = (SIZEOF(None) == 1) + if not eval_hasmateriallayersetusage_wr: + raise AssertionError('Rule hasmateriallayersetusage violated') + else: + return eval_hasmateriallayersetusage_wr + + +#################### + # ENTITY ifcpointoncurve # +#################### +class ifcpointoncurve(ifcpoint): + '''Entity ifcpointoncurve definition. + + :param basiscurve + :type basiscurve:ifccurve + + :param pointparameter + :type pointparameter:ifcparametervalue + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , basiscurve,pointparameter, ): + ifcpoint.__init__(self , ) + self.basiscurve = basiscurve + self.pointparameter = pointparameter + + @apply + def basiscurve(): + def fget( self ): + return self._basiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._basiscurve = ifccurve(value) + else: + self._basiscurve = value + return property(**locals()) + + @apply + def pointparameter(): + def fget( self ): + return self._pointparameter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pointparameter is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._pointparameter = ifcparametervalue(value) + else: + self._pointparameter = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.basiscurve.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcrelsequence # +#################### +class ifcrelsequence(ifcrelconnects): + '''Entity ifcrelsequence definition. + + :param relatingprocess + :type relatingprocess:ifcprocess + + :param relatedprocess + :type relatedprocess:ifcprocess + + :param timelag + :type timelag:ifclagtime + + :param sequencetype + :type sequencetype:ifcsequenceenum + + :param userdefinedsequencetype + :type userdefinedsequencetype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingprocess,relatedprocess,timelag,sequencetype,userdefinedsequencetype, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingprocess = relatingprocess + self.relatedprocess = relatedprocess + self.timelag = timelag + self.sequencetype = sequencetype + self.userdefinedsequencetype = userdefinedsequencetype + + @apply + def relatingprocess(): + def fget( self ): + return self._relatingprocess + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingprocess is mantatory and can not be set to None') + if not check_type(value,ifcprocess): + self._relatingprocess = ifcprocess(value) + else: + self._relatingprocess = value + return property(**locals()) + + @apply + def relatedprocess(): + def fget( self ): + return self._relatedprocess + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedprocess is mantatory and can not be set to None') + if not check_type(value,ifcprocess): + self._relatedprocess = ifcprocess(value) + else: + self._relatedprocess = value + return property(**locals()) + + @apply + def timelag(): + def fget( self ): + return self._timelag + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclagtime): + self._timelag = ifclagtime(value) + else: + self._timelag = value + else: + self._timelag = value + return property(**locals()) + + @apply + def sequencetype(): + def fget( self ): + return self._sequencetype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsequenceenum): + self._sequencetype = ifcsequenceenum(value) + else: + self._sequencetype = value + else: + self._sequencetype = value + return property(**locals()) + + @apply + def userdefinedsequencetype(): + def fget( self ): + return self._userdefinedsequencetype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedsequencetype = ifclabel(value) + else: + self._userdefinedsequencetype = value + else: + self._userdefinedsequencetype = value + return property(**locals()) + def avoidinconsistentsequence(self): + eval_avoidinconsistentsequence_wr = (self.relatingprocess != self.relatedprocess) + if not eval_avoidinconsistentsequence_wr: + raise AssertionError('Rule avoidinconsistentsequence violated') + else: + return eval_avoidinconsistentsequence_wr + + def correctsequencetype(self): + eval_correctsequencetype_wr = ((self.sequencetype != ifcsequenceenum.self.userdefined) or ((self.sequencetype == ifcsequenceenum.self.userdefined) and EXISTS(self.userdefinedsequencetype))) + if not eval_correctsequencetype_wr: + raise AssertionError('Rule correctsequencetype violated') + else: + return eval_correctsequencetype_wr + + +#################### + # ENTITY ifcfacetedbrepwithvoids # +#################### +class ifcfacetedbrepwithvoids(ifcfacetedbrep): + '''Entity ifcfacetedbrepwithvoids definition. + + :param voids + :type voids:SET(1,None,'ifcclosedshell', scope = schema_scope) + ''' + def __init__( self , inherited0__outer , voids, ): + ifcfacetedbrep.__init__(self , inherited0__outer , ) + self.voids = voids + + @apply + def voids(): + def fget( self ): + return self._voids + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument voids is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcclosedshell', scope = schema_scope)): + self._voids = SET(value) + else: + self._voids = value + return property(**locals()) + +#################### + # ENTITY ifccoiltype # +#################### +class ifccoiltype(ifcenergyconversiondevicetype): + '''Entity ifccoiltype definition. + + :param predefinedtype + :type predefinedtype:ifccoiltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccoiltypeenum): + self._predefinedtype = ifccoiltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccoiltypeenum.self.userdefined) or ((self.predefinedtype == ifccoiltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcrelconnectsstructuralmember # +#################### +class ifcrelconnectsstructuralmember(ifcrelconnects): + '''Entity ifcrelconnectsstructuralmember definition. + + :param relatingstructuralmember + :type relatingstructuralmember:ifcstructuralmember + + :param relatedstructuralconnection + :type relatedstructuralconnection:ifcstructuralconnection + + :param appliedcondition + :type appliedcondition:ifcboundarycondition + + :param additionalconditions + :type additionalconditions:ifcstructuralconnectioncondition + + :param supportedlength + :type supportedlength:ifclengthmeasure + + :param conditioncoordinatesystem + :type conditioncoordinatesystem:ifcaxis2placement3d + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingstructuralmember,relatedstructuralconnection,appliedcondition,additionalconditions,supportedlength,conditioncoordinatesystem, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingstructuralmember = relatingstructuralmember + self.relatedstructuralconnection = relatedstructuralconnection + self.appliedcondition = appliedcondition + self.additionalconditions = additionalconditions + self.supportedlength = supportedlength + self.conditioncoordinatesystem = conditioncoordinatesystem + + @apply + def relatingstructuralmember(): + def fget( self ): + return self._relatingstructuralmember + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingstructuralmember is mantatory and can not be set to None') + if not check_type(value,ifcstructuralmember): + self._relatingstructuralmember = ifcstructuralmember(value) + else: + self._relatingstructuralmember = value + return property(**locals()) + + @apply + def relatedstructuralconnection(): + def fget( self ): + return self._relatedstructuralconnection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedstructuralconnection is mantatory and can not be set to None') + if not check_type(value,ifcstructuralconnection): + self._relatedstructuralconnection = ifcstructuralconnection(value) + else: + self._relatedstructuralconnection = value + return property(**locals()) + + @apply + def appliedcondition(): + def fget( self ): + return self._appliedcondition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcboundarycondition): + self._appliedcondition = ifcboundarycondition(value) + else: + self._appliedcondition = value + else: + self._appliedcondition = value + return property(**locals()) + + @apply + def additionalconditions(): + def fget( self ): + return self._additionalconditions + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstructuralconnectioncondition): + self._additionalconditions = ifcstructuralconnectioncondition(value) + else: + self._additionalconditions = value + else: + self._additionalconditions = value + return property(**locals()) + + @apply + def supportedlength(): + def fget( self ): + return self._supportedlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._supportedlength = ifclengthmeasure(value) + else: + self._supportedlength = value + else: + self._supportedlength = value + return property(**locals()) + + @apply + def conditioncoordinatesystem(): + def fget( self ): + return self._conditioncoordinatesystem + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaxis2placement3d): + self._conditioncoordinatesystem = ifcaxis2placement3d(value) + else: + self._conditioncoordinatesystem = value + else: + self._conditioncoordinatesystem = value + return property(**locals()) + +#################### + # ENTITY ifcrelconnectswitheccentricity # +#################### +class ifcrelconnectswitheccentricity(ifcrelconnectsstructuralmember): + '''Entity ifcrelconnectswitheccentricity definition. + + :param connectionconstraint + :type connectionconstraint:ifcconnectiongeometry + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingstructuralmember , inherited5__relatedstructuralconnection , inherited6__appliedcondition , inherited7__additionalconditions , inherited8__supportedlength , inherited9__conditioncoordinatesystem , connectionconstraint, ): + ifcrelconnectsstructuralmember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatingstructuralmember , inherited5__relatedstructuralconnection , inherited6__appliedcondition , inherited7__additionalconditions , inherited8__supportedlength , inherited9__conditioncoordinatesystem , ) + self.connectionconstraint = connectionconstraint + + @apply + def connectionconstraint(): + def fget( self ): + return self._connectionconstraint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument connectionconstraint is mantatory and can not be set to None') + if not check_type(value,ifcconnectiongeometry): + self._connectionconstraint = ifcconnectiongeometry(value) + else: + self._connectionconstraint = value + return property(**locals()) + +#################### + # ENTITY ifcrelfillselement # +#################### +class ifcrelfillselement(ifcrelconnects): + '''Entity ifcrelfillselement definition. + + :param relatingopeningelement + :type relatingopeningelement:ifcopeningelement + + :param relatedbuildingelement + :type relatedbuildingelement:ifcelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingopeningelement,relatedbuildingelement, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingopeningelement = relatingopeningelement + self.relatedbuildingelement = relatedbuildingelement + + @apply + def relatingopeningelement(): + def fget( self ): + return self._relatingopeningelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingopeningelement is mantatory and can not be set to None') + if not check_type(value,ifcopeningelement): + self._relatingopeningelement = ifcopeningelement(value) + else: + self._relatingopeningelement = value + return property(**locals()) + + @apply + def relatedbuildingelement(): + def fget( self ): + return self._relatedbuildingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedbuildingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatedbuildingelement = ifcelement(value) + else: + self._relatedbuildingelement = value + return property(**locals()) + +#################### + # ENTITY ifcrepresentationmap # +#################### +class ifcrepresentationmap(BaseEntityClass): + '''Entity ifcrepresentationmap definition. + + :param mappingorigin + :type mappingorigin:ifcaxis2placement + + :param mappedrepresentation + :type mappedrepresentation:ifcrepresentation + + :param hasshapeaspects + :type hasshapeaspects:SET(0,None,'ifcshapeaspect', scope = schema_scope) + + :param mapusage + :type mapusage:SET(0,None,'ifcmappeditem', scope = schema_scope) + ''' + def __init__( self , mappingorigin,mappedrepresentation, ): + self.mappingorigin = mappingorigin + self.mappedrepresentation = mappedrepresentation + + @apply + def mappingorigin(): + def fget( self ): + return self._mappingorigin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappingorigin is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._mappingorigin = ifcaxis2placement(value) + else: + self._mappingorigin = value + return property(**locals()) + + @apply + def mappedrepresentation(): + def fget( self ): + return self._mappedrepresentation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mappedrepresentation is mantatory and can not be set to None') + if not check_type(value,ifcrepresentation): + self._mappedrepresentation = ifcrepresentation(value) + else: + self._mappedrepresentation = value + return property(**locals()) + + @apply + def hasshapeaspects(): + def fget( self ): + return self._hasshapeaspects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasshapeaspects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def mapusage(): + def fget( self ): + return self._mapusage + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument mapusage is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def applicablemappedrepr(self): + eval_applicablemappedrepr_wr = ('IFC4.IFCSHAPEMODEL' == TYPEOF(self.mappedrepresentation)) + if not eval_applicablemappedrepr_wr: + raise AssertionError('Rule applicablemappedrepr violated') + else: + return eval_applicablemappedrepr_wr + + +#################### + # ENTITY ifcslabelementedcase # +#################### +class ifcslabelementedcase(ifcslab): + '''Entity ifcslabelementedcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ): + ifcslab.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ) + def hasdecomposition(self): + eval_hasdecomposition_wr = (HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) > 0) + if not eval_hasdecomposition_wr: + raise AssertionError('Rule hasdecomposition violated') + else: + return eval_hasdecomposition_wr + + +#################### + # ENTITY ifcpcurve # +#################### +class ifcpcurve(ifccurve): + '''Entity ifcpcurve definition. + + :param basissurface + :type basissurface:ifcsurface + + :param referencecurve + :type referencecurve:ifccurve + ''' + def __init__( self , basissurface,referencecurve, ): + ifccurve.__init__(self , ) + self.basissurface = basissurface + self.referencecurve = referencecurve + + @apply + def basissurface(): + def fget( self ): + return self._basissurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basissurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._basissurface = ifcsurface(value) + else: + self._basissurface = value + return property(**locals()) + + @apply + def referencecurve(): + def fget( self ): + return self._referencecurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument referencecurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._referencecurve = ifccurve(value) + else: + self._referencecurve = value + return property(**locals()) + def dimis2d(self): + eval_dimis2d_wr = (self.referencecurve.self.dim == 2) + if not eval_dimis2d_wr: + raise AssertionError('Rule dimis2d violated') + else: + return eval_dimis2d_wr + + +#################### + # ENTITY ifcvirtualgridintersection # +#################### +class ifcvirtualgridintersection(BaseEntityClass): + '''Entity ifcvirtualgridintersection definition. + + :param intersectingaxes + :type intersectingaxes:LIST(2,2,'ifcgridaxis', scope = schema_scope) + + :param offsetdistances + :type offsetdistances:LIST(2,3,'REAL', scope = schema_scope) + ''' + def __init__( self , intersectingaxes,offsetdistances, ): + self.intersectingaxes = intersectingaxes + self.offsetdistances = offsetdistances + + @apply + def intersectingaxes(): + def fget( self ): + return self._intersectingaxes + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument intersectingaxes is mantatory and can not be set to None') + if not check_type(value,LIST(2,2,'ifcgridaxis', scope = schema_scope)): + self._intersectingaxes = LIST(value) + else: + self._intersectingaxes = value + return property(**locals()) + + @apply + def offsetdistances(): + def fget( self ): + return self._offsetdistances + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument offsetdistances is mantatory and can not be set to None') + if not check_type(value,LIST(2,3,'REAL', scope = schema_scope)): + self._offsetdistances = LIST(value) + else: + self._offsetdistances = value + return property(**locals()) + +#################### + # ENTITY ifccoordinatereferencesystem # +#################### +class ifccoordinatereferencesystem(BaseEntityClass): + '''Entity ifccoordinatereferencesystem definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param geodeticdatum + :type geodeticdatum:ifcidentifier + + :param verticaldatum + :type verticaldatum:ifcidentifier + ''' + def __init__( self , name,description,geodeticdatum,verticaldatum, ): + self.name = name + self.description = description + self.geodeticdatum = geodeticdatum + self.verticaldatum = verticaldatum + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def geodeticdatum(): + def fget( self ): + return self._geodeticdatum + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument geodeticdatum is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._geodeticdatum = ifcidentifier(value) + else: + self._geodeticdatum = value + return property(**locals()) + + @apply + def verticaldatum(): + def fget( self ): + return self._verticaldatum + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._verticaldatum = ifcidentifier(value) + else: + self._verticaldatum = value + else: + self._verticaldatum = value + return property(**locals()) + +#################### + # ENTITY ifclightsourceambient # +#################### +class ifclightsourceambient(ifclightsource): + '''Entity ifclightsourceambient definition. + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ): + ifclightsource.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ) + +#################### + # ENTITY ifcprotectivedevicetrippingunittype # +#################### +class ifcprotectivedevicetrippingunittype(ifcdistributioncontrolelementtype): + '''Entity ifcprotectivedevicetrippingunittype definition. + + :param predefinedtype + :type predefinedtype:ifcprotectivedevicetrippingunittypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcprotectivedevicetrippingunittypeenum): + self._predefinedtype = ifcprotectivedevicetrippingunittypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcprotectivedevicetrippingunittypeenum.self.userdefined) or ((self.predefinedtype == ifcprotectivedevicetrippingunittypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcrelreferencedinspatialstructure # +#################### +class ifcrelreferencedinspatialstructure(ifcrelconnects): + '''Entity ifcrelreferencedinspatialstructure definition. + + :param relatedelements + :type relatedelements:SET(1,None,'ifcproduct', scope = schema_scope) + + :param relatingstructure + :type relatingstructure:ifcspatialelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedelements,relatingstructure, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedelements = relatedelements + self.relatingstructure = relatingstructure + + @apply + def relatedelements(): + def fget( self ): + return self._relatedelements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedelements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproduct', scope = schema_scope)): + self._relatedelements = SET(value) + else: + self._relatedelements = value + return property(**locals()) + + @apply + def relatingstructure(): + def fget( self ): + return self._relatingstructure + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingstructure is mantatory and can not be set to None') + if not check_type(value,ifcspatialelement): + self._relatingstructure = ifcspatialelement(value) + else: + self._relatingstructure = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (SIZEOF(None) == 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifccostvalue # +#################### +class ifccostvalue(ifcappliedvalue): + '''Entity ifccostvalue definition. + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__appliedvalue , inherited3__unitbasis , inherited4__applicabledate , inherited5__fixeduntildate , inherited6__category , inherited7__condition , inherited8__arithmeticoperator , inherited9__components , ): + ifcappliedvalue.__init__(self , inherited0__name , inherited1__description , inherited2__appliedvalue , inherited3__unitbasis , inherited4__applicabledate , inherited5__fixeduntildate , inherited6__category , inherited7__condition , inherited8__arithmeticoperator , inherited9__components , ) + +#################### + # ENTITY ifcfan # +#################### +class ifcfan(ifcflowmovingdevice): + '''Entity ifcfan definition. + + :param predefinedtype + :type predefinedtype:ifcfantypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowmovingdevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfantypeenum): + self._predefinedtype = ifcfantypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcfantypeenum.self.userdefined)) or ((self.predefinedtype == ifcfantypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCFANTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcbsplinecurvewithknots # +#################### +class ifcbsplinecurvewithknots(ifcbsplinecurve): + '''Entity ifcbsplinecurvewithknots definition. + + :param knotmultiplicities + :type knotmultiplicities:LIST(2,None,'INTEGER', scope = schema_scope) + + :param knots + :type knots:LIST(2,None,'REAL', scope = schema_scope) + + :param knotspec + :type knotspec:ifcknottype + + :param upperindexonknots + :type upperindexonknots:INTEGER + ''' + def __init__( self , inherited0__degree , inherited1__controlpointslist , inherited2__curveform , inherited3__closedcurve , inherited4__selfintersect , knotmultiplicities,knots,knotspec, ): + ifcbsplinecurve.__init__(self , inherited0__degree , inherited1__controlpointslist , inherited2__curveform , inherited3__closedcurve , inherited4__selfintersect , ) + self.knotmultiplicities = knotmultiplicities + self.knots = knots + self.knotspec = knotspec + + @apply + def knotmultiplicities(): + def fget( self ): + return self._knotmultiplicities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument knotmultiplicities is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'INTEGER', scope = schema_scope)): + self._knotmultiplicities = LIST(value) + else: + self._knotmultiplicities = value + return property(**locals()) + + @apply + def knots(): + def fget( self ): + return self._knots + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument knots is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._knots = LIST(value) + else: + self._knots = value + return property(**locals()) + + @apply + def knotspec(): + def fget( self ): + return self._knotspec + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument knotspec is mantatory and can not be set to None') + if not check_type(value,ifcknottype): + self._knotspec = ifcknottype(value) + else: + self._knotspec = value + return property(**locals()) + + @apply + def upperindexonknots(): + def fget( self ): + attribute_eval = SIZEOF(self.knots) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument upperindexonknots is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def consistentbspline(self): + eval_consistentbspline_wr = ifcconstraintsparambspline(self.degree,self.upperindexonknots,self.upperindexoncontrolpoints,self.knotmultiplicities,self.knots) + if not eval_consistentbspline_wr: + raise AssertionError('Rule consistentbspline violated') + else: + return eval_consistentbspline_wr + + def correspondingknotlists(self): + eval_correspondingknotlists_wr = (SIZEOF(self.knotmultiplicities) == self.upperindexonknots) + if not eval_correspondingknotlists_wr: + raise AssertionError('Rule correspondingknotlists violated') + else: + return eval_correspondingknotlists_wr + + +#################### + # ENTITY ifcrationalbsplinecurvewithknots # +#################### +class ifcrationalbsplinecurvewithknots(ifcbsplinecurvewithknots): + '''Entity ifcrationalbsplinecurvewithknots definition. + + :param weightsdata + :type weightsdata:LIST(2,None,'REAL', scope = schema_scope) + + :param weights + :type weights:ARRAY(0,upperindexoncontrolpoints,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__degree , inherited1__controlpointslist , inherited2__curveform , inherited3__closedcurve , inherited4__selfintersect , inherited5__knotmultiplicities , inherited6__knots , inherited7__knotspec , weightsdata, ): + ifcbsplinecurvewithknots.__init__(self , inherited0__degree , inherited1__controlpointslist , inherited2__curveform , inherited3__closedcurve , inherited4__selfintersect , inherited5__knotmultiplicities , inherited6__knots , inherited7__knotspec , ) + self.weightsdata = weightsdata + + @apply + def weightsdata(): + def fget( self ): + return self._weightsdata + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument weightsdata is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._weightsdata = LIST(value) + else: + self._weightsdata = value + return property(**locals()) + + @apply + def weights(): + def fget( self ): + attribute_eval = ifclisttoarray(self.weightsdata,0,self.self.ifcbsplinecurve.self.upperindexoncontrolpoints) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument weights is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def samenumofweightsandpoints(self): + eval_samenumofweightsandpoints_wr = (SIZEOF(self.weightsdata) == SIZEOF(self.self.ifcbsplinecurve.self.controlpointslist)) + if not eval_samenumofweightsandpoints_wr: + raise AssertionError('Rule samenumofweightsandpoints violated') + else: + return eval_samenumofweightsandpoints_wr + + def weightsgreaterzero(self): + eval_weightsgreaterzero_wr = ifccurveweightspositive(self) + if not eval_weightsgreaterzero_wr: + raise AssertionError('Rule weightsgreaterzero violated') + else: + return eval_weightsgreaterzero_wr + + +#################### + # ENTITY ifcrooftype # +#################### +class ifcrooftype(ifcbuildingelementtype): + '''Entity ifcrooftype definition. + + :param predefinedtype + :type predefinedtype:ifcrooftypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcrooftypeenum): + self._predefinedtype = ifcrooftypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcrooftypeenum.self.userdefined) or ((self.predefinedtype == ifcrooftypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcimagetexture # +#################### +class ifcimagetexture(ifcsurfacetexture): + '''Entity ifcimagetexture definition. + + :param urlreference + :type urlreference:ifcurireference + ''' + def __init__( self , inherited0__repeats , inherited1__repeatt , inherited2__mode , inherited3__texturetransform , inherited4__parameter , urlreference, ): + ifcsurfacetexture.__init__(self , inherited0__repeats , inherited1__repeatt , inherited2__mode , inherited3__texturetransform , inherited4__parameter , ) + self.urlreference = urlreference + + @apply + def urlreference(): + def fget( self ): + return self._urlreference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument urlreference is mantatory and can not be set to None') + if not check_type(value,ifcurireference): + self._urlreference = ifcurireference(value) + else: + self._urlreference = value + return property(**locals()) + +#################### + # ENTITY ifcloop # +#################### +class ifcloop(ifctopologicalrepresentationitem): + '''Entity ifcloop definition. + ''' + def __init__( self , ): + ifctopologicalrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifcvertexloop # +#################### +class ifcvertexloop(ifcloop): + '''Entity ifcvertexloop definition. + + :param loopvertex + :type loopvertex:ifcvertex + ''' + def __init__( self , loopvertex, ): + ifcloop.__init__(self , ) + self.loopvertex = loopvertex + + @apply + def loopvertex(): + def fget( self ): + return self._loopvertex + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument loopvertex is mantatory and can not be set to None') + if not check_type(value,ifcvertex): + self._loopvertex = ifcvertex(value) + else: + self._loopvertex = value + return property(**locals()) + +#################### + # ENTITY ifcarbitraryclosedprofiledef # +#################### +class ifcarbitraryclosedprofiledef(ifcprofiledef): + '''Entity ifcarbitraryclosedprofiledef definition. + + :param outercurve + :type outercurve:ifccurve + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , outercurve, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.outercurve = outercurve + + @apply + def outercurve(): + def fget( self ): + return self._outercurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument outercurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._outercurve = ifccurve(value) + else: + self._outercurve = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.outercurve.self.dim == 2) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ( not ('IFC4.IFCLINE' == TYPEOF(self.outercurve))) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = ( not ('IFC4.IFCOFFSETCURVE2D' == TYPEOF(self.outercurve))) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcarbitraryprofiledefwithvoids # +#################### +class ifcarbitraryprofiledefwithvoids(ifcarbitraryclosedprofiledef): + '''Entity ifcarbitraryprofiledefwithvoids definition. + + :param innercurves + :type innercurves:SET(1,None,'ifccurve', scope = schema_scope) + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__outercurve , innercurves, ): + ifcarbitraryclosedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__outercurve , ) + self.innercurves = innercurves + + @apply + def innercurves(): + def fget( self ): + return self._innercurves + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument innercurves is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifccurve', scope = schema_scope)): + self._innercurves = SET(value) + else: + self._innercurves = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.self.ifcprofiledef.self.profiletype == area) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = (SIZEOF(None) == 0) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + def wr3(self): + eval_wr3_wr = (SIZEOF(None) == 0) + if not eval_wr3_wr: + raise AssertionError('Rule wr3 violated') + else: + return eval_wr3_wr + + +#################### + # ENTITY ifcsanitaryterminaltype # +#################### +class ifcsanitaryterminaltype(ifcflowterminaltype): + '''Entity ifcsanitaryterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcsanitaryterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcsanitaryterminaltypeenum): + self._predefinedtype = ifcsanitaryterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcsanitaryterminaltypeenum.self.userdefined) or ((self.predefinedtype == ifcsanitaryterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcswitchingdevicetype # +#################### +class ifcswitchingdevicetype(ifcflowcontrollertype): + '''Entity ifcswitchingdevicetype definition. + + :param predefinedtype + :type predefinedtype:ifcswitchingdevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowcontrollertype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcswitchingdevicetypeenum): + self._predefinedtype = ifcswitchingdevicetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcswitchingdevicetypeenum.self.userdefined) or ((self.predefinedtype == ifcswitchingdevicetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcapproval # +#################### +class ifcapproval(BaseEntityClass): + '''Entity ifcapproval definition. + + :param identifier + :type identifier:ifcidentifier + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param timeofapproval + :type timeofapproval:ifcdatetime + + :param status + :type status:ifclabel + + :param level + :type level:ifclabel + + :param qualifier + :type qualifier:ifctext + + :param requestingapproval + :type requestingapproval:ifcactorselect + + :param givingapproval + :type givingapproval:ifcactorselect + + :param hasexternalreferences + :type hasexternalreferences:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + + :param approvedobjects + :type approvedobjects:SET(0,None,'ifcrelassociatesapproval', scope = schema_scope) + + :param approvedresources + :type approvedresources:SET(0,None,'ifcresourceapprovalrelationship', scope = schema_scope) + + :param isrelatedwith + :type isrelatedwith:SET(0,None,'ifcapprovalrelationship', scope = schema_scope) + + :param relates + :type relates:SET(0,None,'ifcapprovalrelationship', scope = schema_scope) + ''' + def __init__( self , identifier,name,description,timeofapproval,status,level,qualifier,requestingapproval,givingapproval, ): + self.identifier = identifier + self.name = name + self.description = description + self.timeofapproval = timeofapproval + self.status = status + self.level = level + self.qualifier = qualifier + self.requestingapproval = requestingapproval + self.givingapproval = givingapproval + + @apply + def identifier(): + def fget( self ): + return self._identifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identifier = ifcidentifier(value) + else: + self._identifier = value + else: + self._identifier = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def timeofapproval(): + def fget( self ): + return self._timeofapproval + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._timeofapproval = ifcdatetime(value) + else: + self._timeofapproval = value + else: + self._timeofapproval = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._status = ifclabel(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def level(): + def fget( self ): + return self._level + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._level = ifclabel(value) + else: + self._level = value + else: + self._level = value + return property(**locals()) + + @apply + def qualifier(): + def fget( self ): + return self._qualifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._qualifier = ifctext(value) + else: + self._qualifier = value + else: + self._qualifier = value + return property(**locals()) + + @apply + def requestingapproval(): + def fget( self ): + return self._requestingapproval + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._requestingapproval = ifcactorselect(value) + else: + self._requestingapproval = value + else: + self._requestingapproval = value + return property(**locals()) + + @apply + def givingapproval(): + def fget( self ): + return self._givingapproval + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._givingapproval = ifcactorselect(value) + else: + self._givingapproval = value + else: + self._givingapproval = value + return property(**locals()) + + @apply + def hasexternalreferences(): + def fget( self ): + return self._hasexternalreferences + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreferences is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def approvedobjects(): + def fget( self ): + return self._approvedobjects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument approvedobjects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def approvedresources(): + def fget( self ): + return self._approvedresources + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument approvedresources is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def isrelatedwith(): + def fget( self ): + return self._isrelatedwith + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isrelatedwith is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def relates(): + def fget( self ): + return self._relates + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument relates is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def hasidentifierorname(self): + eval_hasidentifierorname_wr = (EXISTS(self.identifier) or EXISTS(self.name)) + if not eval_hasidentifierorname_wr: + raise AssertionError('Rule hasidentifierorname violated') + else: + return eval_hasidentifierorname_wr + + +#################### + # ENTITY ifccontroller # +#################### +class ifccontroller(ifcdistributioncontrolelement): + '''Entity ifccontroller definition. + + :param predefinedtype + :type predefinedtype:ifccontrollertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcdistributioncontrolelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccontrollertypeenum): + self._predefinedtype = ifccontrollertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccontrollertypeenum.self.userdefined)) or ((self.predefinedtype == ifccontrollertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCONTROLLERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifccostschedule # +#################### +class ifccostschedule(ifccontrol): + '''Entity ifccostschedule definition. + + :param predefinedtype + :type predefinedtype:ifccostscheduletypeenum + + :param status + :type status:ifclabel + + :param submittedon + :type submittedon:ifcdatetime + + :param updatedate + :type updatedate:ifcdatetime + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , predefinedtype,status,submittedon,updatedate, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , ) + self.predefinedtype = predefinedtype + self.status = status + self.submittedon = submittedon + self.updatedate = updatedate + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostscheduletypeenum): + self._predefinedtype = ifccostscheduletypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._status = ifclabel(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def submittedon(): + def fget( self ): + return self._submittedon + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._submittedon = ifcdatetime(value) + else: + self._submittedon = value + else: + self._submittedon = value + return property(**locals()) + + @apply + def updatedate(): + def fget( self ): + return self._updatedate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._updatedate = ifcdatetime(value) + else: + self._updatedate = value + else: + self._updatedate = value + return property(**locals()) + +#################### + # ENTITY ifclibraryreference # +#################### +class ifclibraryreference(ifcexternalreference): + '''Entity ifclibraryreference definition. + + :param description + :type description:ifctext + + :param language + :type language:ifclanguageid + + :param referencedlibrary + :type referencedlibrary:ifclibraryinformation + + :param libraryrefforobjects + :type libraryrefforobjects:SET(0,None,'ifcrelassociateslibrary', scope = schema_scope) + ''' + def __init__( self , inherited0__location , inherited1__identification , inherited2__name , description,language,referencedlibrary, ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__identification , inherited2__name , ) + self.description = description + self.language = language + self.referencedlibrary = referencedlibrary + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def language(): + def fget( self ): + return self._language + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclanguageid): + self._language = ifclanguageid(value) + else: + self._language = value + else: + self._language = value + return property(**locals()) + + @apply + def referencedlibrary(): + def fget( self ): + return self._referencedlibrary + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclibraryinformation): + self._referencedlibrary = ifclibraryinformation(value) + else: + self._referencedlibrary = value + else: + self._referencedlibrary = value + return property(**locals()) + + @apply + def libraryrefforobjects(): + def fget( self ): + return self._libraryrefforobjects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument libraryrefforobjects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcevent # +#################### +class ifcevent(ifcprocess): + '''Entity ifcevent definition. + + :param predefinedtype + :type predefinedtype:ifceventtypeenum + + :param eventtriggertype + :type eventtriggertype:ifceventtriggertypeenum + + :param userdefinedeventtriggertype + :type userdefinedeventtriggertype:ifclabel + + :param eventoccurencetime + :type eventoccurencetime:ifceventtime + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , predefinedtype,eventtriggertype,userdefinedeventtriggertype,eventoccurencetime, ): + ifcprocess.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , ) + self.predefinedtype = predefinedtype + self.eventtriggertype = eventtriggertype + self.userdefinedeventtriggertype = userdefinedeventtriggertype + self.eventoccurencetime = eventoccurencetime + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifceventtypeenum): + self._predefinedtype = ifceventtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def eventtriggertype(): + def fget( self ): + return self._eventtriggertype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifceventtriggertypeenum): + self._eventtriggertype = ifceventtriggertypeenum(value) + else: + self._eventtriggertype = value + else: + self._eventtriggertype = value + return property(**locals()) + + @apply + def userdefinedeventtriggertype(): + def fget( self ): + return self._userdefinedeventtriggertype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedeventtriggertype = ifclabel(value) + else: + self._userdefinedeventtriggertype = value + else: + self._userdefinedeventtriggertype = value + return property(**locals()) + + @apply + def eventoccurencetime(): + def fget( self ): + return self._eventoccurencetime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifceventtime): + self._eventoccurencetime = ifceventtime(value) + else: + self._eventoccurencetime = value + else: + self._eventoccurencetime = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifceventtypeenum.self.userdefined)) or ((self.predefinedtype == ifceventtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((( not EXISTS(self.eventtriggertype)) or (self.eventtriggertype != ifceventtriggertypeenum.self.userdefined)) or ((self.eventtriggertype == ifceventtriggertypeenum.self.userdefined) and EXISTS(self.userdefinedeventtriggertype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcmateriallist # +#################### +class ifcmateriallist(BaseEntityClass): + '''Entity ifcmateriallist definition. + + :param materials + :type materials:LIST(1,None,'ifcmaterial', scope = schema_scope) + ''' + def __init__( self , materials, ): + self.materials = materials + + @apply + def materials(): + def fget( self ): + return self._materials + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument materials is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcmaterial', scope = schema_scope)): + self._materials = LIST(value) + else: + self._materials = value + return property(**locals()) + +#################### + # ENTITY ifcplatetype # +#################### +class ifcplatetype(ifcbuildingelementtype): + '''Entity ifcplatetype definition. + + :param predefinedtype + :type predefinedtype:ifcplatetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcplatetypeenum): + self._predefinedtype = ifcplatetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcplatetypeenum.self.userdefined) or ((self.predefinedtype == ifcplatetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcreldefines # +#################### +class ifcreldefines(ifcrelationship): + '''Entity ifcreldefines definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + +#################### + # ENTITY ifcreldefinesbytype # +#################### +class ifcreldefinesbytype(ifcreldefines): + '''Entity ifcreldefinesbytype definition. + + :param relatedobjects + :type relatedobjects:SET(1,None,'ifcobject', scope = schema_scope) + + :param relatingtype + :type relatingtype:ifctypeobject + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedobjects,relatingtype, ): + ifcreldefines.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedobjects = relatedobjects + self.relatingtype = relatingtype + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcobject', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + + @apply + def relatingtype(): + def fget( self ): + return self._relatingtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingtype is mantatory and can not be set to None') + if not check_type(value,ifctypeobject): + self._relatingtype = ifctypeobject(value) + else: + self._relatingtype = value + return property(**locals()) + +#################### + # ENTITY ifctable # +#################### +class ifctable(BaseEntityClass): + '''Entity ifctable definition. + + :param name + :type name:ifclabel + + :param rows + :type rows:LIST(1,None,'ifctablerow', scope = schema_scope) + + :param columns + :type columns:LIST(1,None,'ifctablecolumn', scope = schema_scope) + + :param numberofcellsinrow + :type numberofcellsinrow:INTEGER + + :param numberofheadings + :type numberofheadings:INTEGER + + :param numberofdatarows + :type numberofdatarows:INTEGER + ''' + def __init__( self , name,rows,columns, ): + self.name = name + self.rows = rows + self.columns = columns + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def rows(): + def fget( self ): + return self._rows + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifctablerow', scope = schema_scope)): + self._rows = LIST(value) + else: + self._rows = value + else: + self._rows = value + return property(**locals()) + + @apply + def columns(): + def fget( self ): + return self._columns + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifctablecolumn', scope = schema_scope)): + self._columns = LIST(value) + else: + self._columns = value + else: + self._columns = value + return property(**locals()) + + @apply + def numberofcellsinrow(): + def fget( self ): + attribute_eval = HIINDEX(self.rows[1].self.rowcells) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument numberofcellsinrow is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def numberofheadings(): + def fget( self ): + attribute_eval = SIZEOF(None) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument numberofheadings is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def numberofdatarows(): + def fget( self ): + attribute_eval = SIZEOF(None) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument numberofdatarows is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (SIZEOF(None) == 0) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + def wr2(self): + eval_wr2_wr = ((0 <= self.numberofheadings) and (self.numberofheadings <= 1)) + if not eval_wr2_wr: + raise AssertionError('Rule wr2 violated') + else: + return eval_wr2_wr + + +#################### + # ENTITY ifcrailingtype # +#################### +class ifcrailingtype(ifcbuildingelementtype): + '''Entity ifcrailingtype definition. + + :param predefinedtype + :type predefinedtype:ifcrailingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcrailingtypeenum): + self._predefinedtype = ifcrailingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcrailingtypeenum.self.userdefined) or ((self.predefinedtype == ifcrailingtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcfurnituretype # +#################### +class ifcfurnituretype(ifcfurnishingelementtype): + '''Entity ifcfurnituretype definition. + + :param assemblyplace + :type assemblyplace:ifcassemblyplaceenum + + :param predefinedtype + :type predefinedtype:ifcfurnituretypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , assemblyplace,predefinedtype, ): + ifcfurnishingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.assemblyplace = assemblyplace + self.predefinedtype = predefinedtype + + @apply + def assemblyplace(): + def fget( self ): + return self._assemblyplace + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assemblyplace is mantatory and can not be set to None') + if not check_type(value,ifcassemblyplaceenum): + self._assemblyplace = ifcassemblyplaceenum(value) + else: + self._assemblyplace = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfurnituretypeenum): + self._predefinedtype = ifcfurnituretypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcfurnituretypeenum.self.userdefined) or ((self.predefinedtype == ifcfurnituretypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcfiresuppressionterminaltype # +#################### +class ifcfiresuppressionterminaltype(ifcflowterminaltype): + '''Entity ifcfiresuppressionterminaltype definition. + + :param predefinedtype + :type predefinedtype:ifcfiresuppressionterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcfiresuppressionterminaltypeenum): + self._predefinedtype = ifcfiresuppressionterminaltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcfiresuppressionterminaltypeenum.self.userdefined) or ((self.predefinedtype == ifcfiresuppressionterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifctendonanchor # +#################### +class ifctendonanchor(ifcreinforcingelement): + '''Entity ifctendonanchor definition. + + :param predefinedtype + :type predefinedtype:ifctendonanchortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , predefinedtype, ): + ifcreinforcingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__steelgrade , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctendonanchortypeenum): + self._predefinedtype = ifctendonanchortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifctendonanchortypeenum.self.userdefined)) or ((self.predefinedtype == ifctendonanchortypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCTENDONANCHORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcmedicaldevice # +#################### +class ifcmedicaldevice(ifcflowterminal): + '''Entity ifcmedicaldevice definition. + + :param predefinedtype + :type predefinedtype:ifcmedicaldevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmedicaldevicetypeenum): + self._predefinedtype = ifcmedicaldevicetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcmedicaldevicetypeenum.self.userdefined)) or ((self.predefinedtype == ifcmedicaldevicetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCMEDICALDEVICETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcconstructionequipmentresource # +#################### +class ifcconstructionequipmentresource(ifcconstructionresource): + '''Entity ifcconstructionequipmentresource definition. + + :param predefinedtype + :type predefinedtype:ifcconstructionequipmentresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , predefinedtype, ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcconstructionequipmentresourcetypeenum): + self._predefinedtype = ifcconstructionequipmentresourcetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcconstructionequipmentresourcetypeenum.self.userdefined)) or ((self.predefinedtype == ifcconstructionequipmentresourcetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifctexturevertex # +#################### +class ifctexturevertex(ifcpresentationitem): + '''Entity ifctexturevertex definition. + + :param coordinates + :type coordinates:LIST(2,2,'REAL', scope = schema_scope) + ''' + def __init__( self , coordinates, ): + ifcpresentationitem.__init__(self , ) + self.coordinates = coordinates + + @apply + def coordinates(): + def fget( self ): + return self._coordinates + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordinates is mantatory and can not be set to None') + if not check_type(value,LIST(2,2,'REAL', scope = schema_scope)): + self._coordinates = LIST(value) + else: + self._coordinates = value + return property(**locals()) + +#################### + # ENTITY ifcpile # +#################### +class ifcpile(ifcbuildingelement): + '''Entity ifcpile definition. + + :param predefinedtype + :type predefinedtype:ifcpiletypeenum + + :param constructiontype + :type constructiontype:ifcpileconstructionenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype,constructiontype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + self.constructiontype = constructiontype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpiletypeenum): + self._predefinedtype = ifcpiletypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def constructiontype(): + def fget( self ): + return self._constructiontype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpileconstructionenum): + self._constructiontype = ifcpileconstructionenum(value) + else: + self._constructiontype = value + else: + self._constructiontype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcpiletypeenum.self.userdefined)) or ((self.predefinedtype == ifcpiletypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCPILETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcreinforcingmeshtype # +#################### +class ifcreinforcingmeshtype(ifcreinforcingelementtype): + '''Entity ifcreinforcingmeshtype definition. + + :param predefinedtype + :type predefinedtype:ifcreinforcingmeshtypeenum + + :param meshlength + :type meshlength:ifcpositivelengthmeasure + + :param meshwidth + :type meshwidth:ifcpositivelengthmeasure + + :param longitudinalbarnominaldiameter + :type longitudinalbarnominaldiameter:ifcpositivelengthmeasure + + :param transversebarnominaldiameter + :type transversebarnominaldiameter:ifcpositivelengthmeasure + + :param longitudinalbarcrosssectionarea + :type longitudinalbarcrosssectionarea:ifcareameasure + + :param transversebarcrosssectionarea + :type transversebarcrosssectionarea:ifcareameasure + + :param longitudinalbarspacing + :type longitudinalbarspacing:ifcpositivelengthmeasure + + :param transversebarspacing + :type transversebarspacing:ifcpositivelengthmeasure + + :param bendingshapecode + :type bendingshapecode:ifclabel + + :param bendingparameters + :type bendingparameters:LIST(1,None,'ifcbendingparameterselect', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype,meshlength,meshwidth,longitudinalbarnominaldiameter,transversebarnominaldiameter,longitudinalbarcrosssectionarea,transversebarcrosssectionarea,longitudinalbarspacing,transversebarspacing,bendingshapecode,bendingparameters, ): + ifcreinforcingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + self.meshlength = meshlength + self.meshwidth = meshwidth + self.longitudinalbarnominaldiameter = longitudinalbarnominaldiameter + self.transversebarnominaldiameter = transversebarnominaldiameter + self.longitudinalbarcrosssectionarea = longitudinalbarcrosssectionarea + self.transversebarcrosssectionarea = transversebarcrosssectionarea + self.longitudinalbarspacing = longitudinalbarspacing + self.transversebarspacing = transversebarspacing + self.bendingshapecode = bendingshapecode + self.bendingparameters = bendingparameters + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcreinforcingmeshtypeenum): + self._predefinedtype = ifcreinforcingmeshtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def meshlength(): + def fget( self ): + return self._meshlength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._meshlength = ifcpositivelengthmeasure(value) + else: + self._meshlength = value + else: + self._meshlength = value + return property(**locals()) + + @apply + def meshwidth(): + def fget( self ): + return self._meshwidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._meshwidth = ifcpositivelengthmeasure(value) + else: + self._meshwidth = value + else: + self._meshwidth = value + return property(**locals()) + + @apply + def longitudinalbarnominaldiameter(): + def fget( self ): + return self._longitudinalbarnominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._longitudinalbarnominaldiameter = ifcpositivelengthmeasure(value) + else: + self._longitudinalbarnominaldiameter = value + else: + self._longitudinalbarnominaldiameter = value + return property(**locals()) + + @apply + def transversebarnominaldiameter(): + def fget( self ): + return self._transversebarnominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._transversebarnominaldiameter = ifcpositivelengthmeasure(value) + else: + self._transversebarnominaldiameter = value + else: + self._transversebarnominaldiameter = value + return property(**locals()) + + @apply + def longitudinalbarcrosssectionarea(): + def fget( self ): + return self._longitudinalbarcrosssectionarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._longitudinalbarcrosssectionarea = ifcareameasure(value) + else: + self._longitudinalbarcrosssectionarea = value + else: + self._longitudinalbarcrosssectionarea = value + return property(**locals()) + + @apply + def transversebarcrosssectionarea(): + def fget( self ): + return self._transversebarcrosssectionarea + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcareameasure): + self._transversebarcrosssectionarea = ifcareameasure(value) + else: + self._transversebarcrosssectionarea = value + else: + self._transversebarcrosssectionarea = value + return property(**locals()) + + @apply + def longitudinalbarspacing(): + def fget( self ): + return self._longitudinalbarspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._longitudinalbarspacing = ifcpositivelengthmeasure(value) + else: + self._longitudinalbarspacing = value + else: + self._longitudinalbarspacing = value + return property(**locals()) + + @apply + def transversebarspacing(): + def fget( self ): + return self._transversebarspacing + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._transversebarspacing = ifcpositivelengthmeasure(value) + else: + self._transversebarspacing = value + else: + self._transversebarspacing = value + return property(**locals()) + + @apply + def bendingshapecode(): + def fget( self ): + return self._bendingshapecode + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._bendingshapecode = ifclabel(value) + else: + self._bendingshapecode = value + else: + self._bendingshapecode = value + return property(**locals()) + + @apply + def bendingparameters(): + def fget( self ): + return self._bendingparameters + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcbendingparameterselect', scope = schema_scope)): + self._bendingparameters = LIST(value) + else: + self._bendingparameters = value + else: + self._bendingparameters = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcreinforcingmeshtypeenum.self.userdefined) or ((self.predefinedtype == ifcreinforcingmeshtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def bendingshapecodeprovided(self): + eval_bendingshapecodeprovided_wr = (( not EXISTS(self.bendingparameters)) or EXISTS(self.bendingshapecode)) + if not eval_bendingshapecodeprovided_wr: + raise AssertionError('Rule bendingshapecodeprovided violated') + else: + return eval_bendingshapecodeprovided_wr + + +#################### + # ENTITY ifcrelassociateslibrary # +#################### +class ifcrelassociateslibrary(ifcrelassociates): + '''Entity ifcrelassociateslibrary definition. + + :param relatinglibrary + :type relatinglibrary:ifclibraryselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatinglibrary, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatinglibrary = relatinglibrary + + @apply + def relatinglibrary(): + def fget( self ): + return self._relatinglibrary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatinglibrary is mantatory and can not be set to None') + if not check_type(value,ifclibraryselect): + self._relatinglibrary = ifclibraryselect(value) + else: + self._relatinglibrary = value + return property(**locals()) + +#################### + # ENTITY ifcsimplepropertytemplate # +#################### +class ifcsimplepropertytemplate(ifcpropertytemplate): + '''Entity ifcsimplepropertytemplate definition. + + :param templatetype + :type templatetype:ifcsimplepropertytemplatetypeenum + + :param primarymeasuretype + :type primarymeasuretype:ifclabel + + :param secondarymeasuretype + :type secondarymeasuretype:ifclabel + + :param enumerators + :type enumerators:ifcpropertyenumeration + + :param primaryunit + :type primaryunit:ifcunit + + :param secondaryunit + :type secondaryunit:ifcunit + + :param expression + :type expression:ifclabel + + :param accessstate + :type accessstate:ifcstateenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , templatetype,primarymeasuretype,secondarymeasuretype,enumerators,primaryunit,secondaryunit,expression,accessstate, ): + ifcpropertytemplate.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.templatetype = templatetype + self.primarymeasuretype = primarymeasuretype + self.secondarymeasuretype = secondarymeasuretype + self.enumerators = enumerators + self.primaryunit = primaryunit + self.secondaryunit = secondaryunit + self.expression = expression + self.accessstate = accessstate + + @apply + def templatetype(): + def fget( self ): + return self._templatetype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsimplepropertytemplatetypeenum): + self._templatetype = ifcsimplepropertytemplatetypeenum(value) + else: + self._templatetype = value + else: + self._templatetype = value + return property(**locals()) + + @apply + def primarymeasuretype(): + def fget( self ): + return self._primarymeasuretype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._primarymeasuretype = ifclabel(value) + else: + self._primarymeasuretype = value + else: + self._primarymeasuretype = value + return property(**locals()) + + @apply + def secondarymeasuretype(): + def fget( self ): + return self._secondarymeasuretype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._secondarymeasuretype = ifclabel(value) + else: + self._secondarymeasuretype = value + else: + self._secondarymeasuretype = value + return property(**locals()) + + @apply + def enumerators(): + def fget( self ): + return self._enumerators + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpropertyenumeration): + self._enumerators = ifcpropertyenumeration(value) + else: + self._enumerators = value + else: + self._enumerators = value + return property(**locals()) + + @apply + def primaryunit(): + def fget( self ): + return self._primaryunit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._primaryunit = ifcunit(value) + else: + self._primaryunit = value + else: + self._primaryunit = value + return property(**locals()) + + @apply + def secondaryunit(): + def fget( self ): + return self._secondaryunit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._secondaryunit = ifcunit(value) + else: + self._secondaryunit = value + else: + self._secondaryunit = value + return property(**locals()) + + @apply + def expression(): + def fget( self ): + return self._expression + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._expression = ifclabel(value) + else: + self._expression = value + else: + self._expression = value + return property(**locals()) + + @apply + def accessstate(): + def fget( self ): + return self._accessstate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstateenum): + self._accessstate = ifcstateenum(value) + else: + self._accessstate = value + else: + self._accessstate = value + return property(**locals()) + +#################### + # ENTITY ifcrectanglehollowprofiledef # +#################### +class ifcrectanglehollowprofiledef(ifcrectangleprofiledef): + '''Entity ifcrectanglehollowprofiledef definition. + + :param wallthickness + :type wallthickness:ifcpositivelengthmeasure + + :param innerfilletradius + :type innerfilletradius:ifcnonnegativelengthmeasure + + :param outerfilletradius + :type outerfilletradius:ifcnonnegativelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__xdim , inherited4__ydim , wallthickness,innerfilletradius,outerfilletradius, ): + ifcrectangleprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__xdim , inherited4__ydim , ) + self.wallthickness = wallthickness + self.innerfilletradius = innerfilletradius + self.outerfilletradius = outerfilletradius + + @apply + def wallthickness(): + def fget( self ): + return self._wallthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument wallthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._wallthickness = ifcpositivelengthmeasure(value) + else: + self._wallthickness = value + return property(**locals()) + + @apply + def innerfilletradius(): + def fget( self ): + return self._innerfilletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._innerfilletradius = ifcnonnegativelengthmeasure(value) + else: + self._innerfilletradius = value + else: + self._innerfilletradius = value + return property(**locals()) + + @apply + def outerfilletradius(): + def fget( self ): + return self._outerfilletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._outerfilletradius = ifcnonnegativelengthmeasure(value) + else: + self._outerfilletradius = value + else: + self._outerfilletradius = value + return property(**locals()) + def validwallthickness(self): + eval_validwallthickness_wr = ((self.wallthickness < (self.self.ifcrectangleprofiledef.self.xdim / 2)) and (self.wallthickness < (self.self.ifcrectangleprofiledef.self.ydim / 2))) + if not eval_validwallthickness_wr: + raise AssertionError('Rule validwallthickness violated') + else: + return eval_validwallthickness_wr + + def validinnerradius(self): + eval_validinnerradius_wr = (( not EXISTS(self.innerfilletradius)) or ((self.innerfilletradius <= ((self.self.ifcrectangleprofiledef.self.xdim / 2) - self.wallthickness)) and (self.innerfilletradius <= ((self.self.ifcrectangleprofiledef.self.ydim / 2) - self.wallthickness)))) + if not eval_validinnerradius_wr: + raise AssertionError('Rule validinnerradius violated') + else: + return eval_validinnerradius_wr + + def validouterradius(self): + eval_validouterradius_wr = (( not EXISTS(self.outerfilletradius)) or ((self.outerfilletradius <= (self.self.ifcrectangleprofiledef.self.xdim / 2)) and (self.outerfilletradius <= (self.self.ifcrectangleprofiledef.self.ydim / 2)))) + if not eval_validouterradius_wr: + raise AssertionError('Rule validouterradius violated') + else: + return eval_validouterradius_wr + + +#################### + # ENTITY ifcproxy # +#################### +class ifcproxy(ifcproduct): + '''Entity ifcproxy definition. + + :param proxytype + :type proxytype:ifcobjecttypeenum + + :param tag + :type tag:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , proxytype,tag, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.proxytype = proxytype + self.tag = tag + + @apply + def proxytype(): + def fget( self ): + return self._proxytype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument proxytype is mantatory and can not be set to None') + if not check_type(value,ifcobjecttypeenum): + self._proxytype = ifcobjecttypeenum(value) + else: + self._proxytype = value + return property(**locals()) + + @apply + def tag(): + def fget( self ): + return self._tag + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._tag = ifclabel(value) + else: + self._tag = value + else: + self._tag = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrevolvedareasolidtapered # +#################### +class ifcrevolvedareasolidtapered(ifcrevolvedareasolid): + '''Entity ifcrevolvedareasolidtapered definition. + + :param endsweptarea + :type endsweptarea:ifcprofiledef + ''' + def __init__( self , inherited0__sweptarea , inherited1__position , inherited2__axis , inherited3__angle , endsweptarea, ): + ifcrevolvedareasolid.__init__(self , inherited0__sweptarea , inherited1__position , inherited2__axis , inherited3__angle , ) + self.endsweptarea = endsweptarea + + @apply + def endsweptarea(): + def fget( self ): + return self._endsweptarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument endsweptarea is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._endsweptarea = ifcprofiledef(value) + else: + self._endsweptarea = value + return property(**locals()) + def correctprofileassignment(self): + eval_correctprofileassignment_wr = ifctaperedsweptareaprofiles(self.self.ifcsweptareasolid.self.sweptarea,self.self.endsweptarea) + if not eval_correctprofileassignment_wr: + raise AssertionError('Rule correctprofileassignment violated') + else: + return eval_correctprofileassignment_wr + + +#################### + # ENTITY ifcwallelementedcase # +#################### +class ifcwallelementedcase(ifcwall): + '''Entity ifcwallelementedcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ): + ifcwall.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ) + def hasdecomposition(self): + eval_hasdecomposition_wr = (HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) > 0) + if not eval_hasdecomposition_wr: + raise AssertionError('Rule hasdecomposition violated') + else: + return eval_hasdecomposition_wr + + +#################### + # ENTITY ifcevaporator # +#################### +class ifcevaporator(ifcenergyconversiondevice): + '''Entity ifcevaporator definition. + + :param predefinedtype + :type predefinedtype:ifcevaporatortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcevaporatortypeenum): + self._predefinedtype = ifcevaporatortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcevaporatortypeenum.self.userdefined)) or ((self.predefinedtype == ifcevaporatortypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCEVAPORATORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcprojectedcrs # +#################### +class ifcprojectedcrs(ifccoordinatereferencesystem): + '''Entity ifcprojectedcrs definition. + + :param mapprojection + :type mapprojection:ifcidentifier + + :param mapzone + :type mapzone:ifcidentifier + + :param mapunit + :type mapunit:ifcnamedunit + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__geodeticdatum , inherited3__verticaldatum , mapprojection,mapzone,mapunit, ): + ifccoordinatereferencesystem.__init__(self , inherited0__name , inherited1__description , inherited2__geodeticdatum , inherited3__verticaldatum , ) + self.mapprojection = mapprojection + self.mapzone = mapzone + self.mapunit = mapunit + + @apply + def mapprojection(): + def fget( self ): + return self._mapprojection + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._mapprojection = ifcidentifier(value) + else: + self._mapprojection = value + else: + self._mapprojection = value + return property(**locals()) + + @apply + def mapzone(): + def fget( self ): + return self._mapzone + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._mapzone = ifcidentifier(value) + else: + self._mapzone = value + else: + self._mapzone = value + return property(**locals()) + + @apply + def mapunit(): + def fget( self ): + return self._mapunit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnamedunit): + self._mapunit = ifcnamedunit(value) + else: + self._mapunit = value + else: + self._mapunit = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (( not EXISTS(self.mapunit)) or (self.mapunit.self.unittype == ifcunitenum.self.lengthunit)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + +#################### + # ENTITY ifcwindowtype # +#################### +class ifcwindowtype(ifcbuildingelementtype): + '''Entity ifcwindowtype definition. + + :param predefinedtype + :type predefinedtype:ifcwindowtypeenum + + :param partitioningtype + :type partitioningtype:ifcwindowtypepartitioningenum + + :param parametertakesprecedence + :type parametertakesprecedence:BOOLEAN + + :param userdefinedpartitioningtype + :type userdefinedpartitioningtype:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype,partitioningtype,parametertakesprecedence,userdefinedpartitioningtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + self.partitioningtype = partitioningtype + self.parametertakesprecedence = parametertakesprecedence + self.userdefinedpartitioningtype = userdefinedpartitioningtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcwindowtypeenum): + self._predefinedtype = ifcwindowtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def partitioningtype(): + def fget( self ): + return self._partitioningtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument partitioningtype is mantatory and can not be set to None') + if not check_type(value,ifcwindowtypepartitioningenum): + self._partitioningtype = ifcwindowtypepartitioningenum(value) + else: + self._partitioningtype = value + return property(**locals()) + + @apply + def parametertakesprecedence(): + def fget( self ): + return self._parametertakesprecedence + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._parametertakesprecedence = BOOLEAN(value) + else: + self._parametertakesprecedence = value + else: + self._parametertakesprecedence = value + return property(**locals()) + + @apply + def userdefinedpartitioningtype(): + def fget( self ): + return self._userdefinedpartitioningtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedpartitioningtype = ifclabel(value) + else: + self._userdefinedpartitioningtype = value + else: + self._userdefinedpartitioningtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcwindowtypeenum.self.userdefined) or ((self.predefinedtype == ifcwindowtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpropertyboundedvalue # +#################### +class ifcpropertyboundedvalue(ifcsimpleproperty): + '''Entity ifcpropertyboundedvalue definition. + + :param upperboundvalue + :type upperboundvalue:ifcvalue + + :param lowerboundvalue + :type lowerboundvalue:ifcvalue + + :param unit + :type unit:ifcunit + + :param setpointvalue + :type setpointvalue:ifcvalue + ''' + def __init__( self , inherited0__name , inherited1__description , upperboundvalue,lowerboundvalue,unit,setpointvalue, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.upperboundvalue = upperboundvalue + self.lowerboundvalue = lowerboundvalue + self.unit = unit + self.setpointvalue = setpointvalue + + @apply + def upperboundvalue(): + def fget( self ): + return self._upperboundvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvalue): + self._upperboundvalue = ifcvalue(value) + else: + self._upperboundvalue = value + else: + self._upperboundvalue = value + return property(**locals()) + + @apply + def lowerboundvalue(): + def fget( self ): + return self._lowerboundvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvalue): + self._lowerboundvalue = ifcvalue(value) + else: + self._lowerboundvalue = value + else: + self._lowerboundvalue = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + + @apply + def setpointvalue(): + def fget( self ): + return self._setpointvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvalue): + self._setpointvalue = ifcvalue(value) + else: + self._setpointvalue = value + else: + self._setpointvalue = value + return property(**locals()) + def sameunitupperlower(self): + eval_sameunitupperlower_wr = ((( not EXISTS(self.upperboundvalue)) or ( not EXISTS(self.lowerboundvalue))) or (TYPEOF(self.upperboundvalue) == TYPEOF(self.lowerboundvalue))) + if not eval_sameunitupperlower_wr: + raise AssertionError('Rule sameunitupperlower violated') + else: + return eval_sameunitupperlower_wr + + def sameunitupperset(self): + eval_sameunitupperset_wr = ((( not EXISTS(self.upperboundvalue)) or ( not EXISTS(self.setpointvalue))) or (TYPEOF(self.upperboundvalue) == TYPEOF(self.setpointvalue))) + if not eval_sameunitupperset_wr: + raise AssertionError('Rule sameunitupperset violated') + else: + return eval_sameunitupperset_wr + + def sameunitlowerset(self): + eval_sameunitlowerset_wr = ((( not EXISTS(self.lowerboundvalue)) or ( not EXISTS(self.setpointvalue))) or (TYPEOF(self.lowerboundvalue) == TYPEOF(self.setpointvalue))) + if not eval_sameunitlowerset_wr: + raise AssertionError('Rule sameunitlowerset violated') + else: + return eval_sameunitlowerset_wr + + +#################### + # ENTITY ifcpump # +#################### +class ifcpump(ifcflowmovingdevice): + '''Entity ifcpump definition. + + :param predefinedtype + :type predefinedtype:ifcpumptypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowmovingdevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpumptypeenum): + self._predefinedtype = ifcpumptypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcpumptypeenum.self.userdefined)) or ((self.predefinedtype == ifcpumptypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCPUMPTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcpresentationstyleassignment # +#################### +class ifcpresentationstyleassignment(BaseEntityClass): + '''Entity ifcpresentationstyleassignment definition. + + :param styles + :type styles:SET(1,None,'ifcpresentationstyleselect', scope = schema_scope) + ''' + def __init__( self , styles, ): + self.styles = styles + + @apply + def styles(): + def fget( self ): + return self._styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcpresentationstyleselect', scope = schema_scope)): + self._styles = SET(value) + else: + self._styles = value + return property(**locals()) + +#################### + # ENTITY ifcexternalreferencerelationship # +#################### +class ifcexternalreferencerelationship(ifcresourcelevelrelationship): + '''Entity ifcexternalreferencerelationship definition. + + :param relatingreference + :type relatingreference:ifcexternalreference + + :param relatedresourceobjects + :type relatedresourceobjects:SET(1,None,'ifcresourceobjectselect', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , relatingreference,relatedresourceobjects, ): + ifcresourcelevelrelationship.__init__(self , inherited0__name , inherited1__description , ) + self.relatingreference = relatingreference + self.relatedresourceobjects = relatedresourceobjects + + @apply + def relatingreference(): + def fget( self ): + return self._relatingreference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingreference is mantatory and can not be set to None') + if not check_type(value,ifcexternalreference): + self._relatingreference = ifcexternalreference(value) + else: + self._relatingreference = value + return property(**locals()) + + @apply + def relatedresourceobjects(): + def fget( self ): + return self._relatedresourceobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedresourceobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcresourceobjectselect', scope = schema_scope)): + self._relatedresourceobjects = SET(value) + else: + self._relatedresourceobjects = value + return property(**locals()) + +#################### + # ENTITY ifcmirroredprofiledef # +#################### +class ifcmirroredprofiledef(ifcderivedprofiledef): + '''Entity ifcmirroredprofiledef definition. + + :param ifcderivedprofiledef_operator + :type ifcderivedprofiledef_operator:ifccartesiantransformationoperator2d + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__parentprofile , inherited3__operator , inherited4__label , ): + ifcderivedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__parentprofile , inherited3__operator , inherited4__label , ) + + @apply + def ifcderivedprofiledef_operator(): + def fget( self ): + attribute_eval = (((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifccartesiantransformationoperator((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([-1,0]),(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,1]),((ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcpoint()) == ifccartesianpoint([0,0]),1)) == ifccartesiantransformationoperator2d()) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcderivedprofiledef_operator is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsite # +#################### +class ifcsite(ifcspatialstructureelement): + '''Entity ifcsite definition. + + :param reflatitude + :type reflatitude:LIST(3,4,'INTEGER', scope = schema_scope) + + :param reflongitude + :type reflongitude:LIST(3,4,'INTEGER', scope = schema_scope) + + :param refelevation + :type refelevation:ifclengthmeasure + + :param landtitlenumber + :type landtitlenumber:ifclabel + + :param siteaddress + :type siteaddress:ifcpostaladdress + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , reflatitude,reflongitude,refelevation,landtitlenumber,siteaddress, ): + ifcspatialstructureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , ) + self.reflatitude = reflatitude + self.reflongitude = reflongitude + self.refelevation = refelevation + self.landtitlenumber = landtitlenumber + self.siteaddress = siteaddress + + @apply + def reflatitude(): + def fget( self ): + return self._reflatitude + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(3,4,'INTEGER', scope = schema_scope)): + self._reflatitude = LIST(value) + else: + self._reflatitude = value + else: + self._reflatitude = value + return property(**locals()) + + @apply + def reflongitude(): + def fget( self ): + return self._reflongitude + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(3,4,'INTEGER', scope = schema_scope)): + self._reflongitude = LIST(value) + else: + self._reflongitude = value + else: + self._reflongitude = value + return property(**locals()) + + @apply + def refelevation(): + def fget( self ): + return self._refelevation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._refelevation = ifclengthmeasure(value) + else: + self._refelevation = value + else: + self._refelevation = value + return property(**locals()) + + @apply + def landtitlenumber(): + def fget( self ): + return self._landtitlenumber + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._landtitlenumber = ifclabel(value) + else: + self._landtitlenumber = value + else: + self._landtitlenumber = value + return property(**locals()) + + @apply + def siteaddress(): + def fget( self ): + return self._siteaddress + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpostaladdress): + self._siteaddress = ifcpostaladdress(value) + else: + self._siteaddress = value + else: + self._siteaddress = value + return property(**locals()) + +#################### + # ENTITY ifcarbitraryopenprofiledef # +#################### +class ifcarbitraryopenprofiledef(ifcprofiledef): + '''Entity ifcarbitraryopenprofiledef definition. + + :param curve + :type curve:ifcboundedcurve + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , curve, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.curve = curve + + @apply + def curve(): + def fget( self ): + return self._curve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curve is mantatory and can not be set to None') + if not check_type(value,ifcboundedcurve): + self._curve = ifcboundedcurve(value) + else: + self._curve = value + return property(**locals()) + def wr11(self): + eval_wr11_wr = (('IFC4.IFCCENTERLINEPROFILEDEF' == TYPEOF(self)) or (self.self.ifcprofiledef.self.profiletype == ifcprofiletypeenum.self.curve)) + if not eval_wr11_wr: + raise AssertionError('Rule wr11 violated') + else: + return eval_wr11_wr + + def wr12(self): + eval_wr12_wr = (self.curve.self.dim == 2) + if not eval_wr12_wr: + raise AssertionError('Rule wr12 violated') + else: + return eval_wr12_wr + + +#################### + # ENTITY ifccoil # +#################### +class ifccoil(ifcenergyconversiondevice): + '''Entity ifccoil definition. + + :param predefinedtype + :type predefinedtype:ifccoiltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccoiltypeenum): + self._predefinedtype = ifccoiltypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccoiltypeenum.self.userdefined)) or ((self.predefinedtype == ifccoiltypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCOILTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcquantitylength # +#################### +class ifcquantitylength(ifcphysicalsimplequantity): + '''Entity ifcquantitylength definition. + + :param lengthvalue + :type lengthvalue:ifclengthmeasure + + :param formula + :type formula:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , lengthvalue,formula, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.lengthvalue = lengthvalue + self.formula = formula + + @apply + def lengthvalue(): + def fget( self ): + return self._lengthvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lengthvalue is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._lengthvalue = ifclengthmeasure(value) + else: + self._lengthvalue = value + return property(**locals()) + + @apply + def formula(): + def fget( self ): + return self._formula + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._formula = ifclabel(value) + else: + self._formula = value + else: + self._formula = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.lengthunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.lengthvalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcsubcontractresource # +#################### +class ifcsubcontractresource(ifcconstructionresource): + '''Entity ifcsubcontractresource definition. + + :param predefinedtype + :type predefinedtype:ifcsubcontractresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , predefinedtype, ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsubcontractresourcetypeenum): + self._predefinedtype = ifcsubcontractresourcetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcsubcontractresourcetypeenum.self.userdefined)) or ((self.predefinedtype == ifcsubcontractresourcetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifctimeseries # +#################### +class ifctimeseries(BaseEntityClass): + '''Entity ifctimeseries definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param starttime + :type starttime:ifcdatetime + + :param endtime + :type endtime:ifcdatetime + + :param timeseriesdatatype + :type timeseriesdatatype:ifctimeseriesdatatypeenum + + :param dataorigin + :type dataorigin:ifcdataoriginenum + + :param userdefineddataorigin + :type userdefineddataorigin:ifclabel + + :param unit + :type unit:ifcunit + + :param hasexternalreference + :type hasexternalreference:SET(1,None,'ifcexternalreferencerelationship', scope = schema_scope) + ''' + def __init__( self , name,description,starttime,endtime,timeseriesdatatype,dataorigin,userdefineddataorigin,unit, ): + self.name = name + self.description = description + self.starttime = starttime + self.endtime = endtime + self.timeseriesdatatype = timeseriesdatatype + self.dataorigin = dataorigin + self.userdefineddataorigin = userdefineddataorigin + self.unit = unit + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def starttime(): + def fget( self ): + return self._starttime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument starttime is mantatory and can not be set to None') + if not check_type(value,ifcdatetime): + self._starttime = ifcdatetime(value) + else: + self._starttime = value + return property(**locals()) + + @apply + def endtime(): + def fget( self ): + return self._endtime + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument endtime is mantatory and can not be set to None') + if not check_type(value,ifcdatetime): + self._endtime = ifcdatetime(value) + else: + self._endtime = value + return property(**locals()) + + @apply + def timeseriesdatatype(): + def fget( self ): + return self._timeseriesdatatype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timeseriesdatatype is mantatory and can not be set to None') + if not check_type(value,ifctimeseriesdatatypeenum): + self._timeseriesdatatype = ifctimeseriesdatatypeenum(value) + else: + self._timeseriesdatatype = value + return property(**locals()) + + @apply + def dataorigin(): + def fget( self ): + return self._dataorigin + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument dataorigin is mantatory and can not be set to None') + if not check_type(value,ifcdataoriginenum): + self._dataorigin = ifcdataoriginenum(value) + else: + self._dataorigin = value + return property(**locals()) + + @apply + def userdefineddataorigin(): + def fget( self ): + return self._userdefineddataorigin + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefineddataorigin = ifclabel(value) + else: + self._userdefineddataorigin = value + else: + self._userdefineddataorigin = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + + @apply + def hasexternalreference(): + def fget( self ): + return self._hasexternalreference + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreference is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcregulartimeseries # +#################### +class ifcregulartimeseries(ifctimeseries): + '''Entity ifcregulartimeseries definition. + + :param timestep + :type timestep:ifctimemeasure + + :param values + :type values:LIST(1,None,'ifctimeseriesvalue', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__starttime , inherited3__endtime , inherited4__timeseriesdatatype , inherited5__dataorigin , inherited6__userdefineddataorigin , inherited7__unit , timestep,values, ): + ifctimeseries.__init__(self , inherited0__name , inherited1__description , inherited2__starttime , inherited3__endtime , inherited4__timeseriesdatatype , inherited5__dataorigin , inherited6__userdefineddataorigin , inherited7__unit , ) + self.timestep = timestep + self.values = values + + @apply + def timestep(): + def fget( self ): + return self._timestep + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timestep is mantatory and can not be set to None') + if not check_type(value,ifctimemeasure): + self._timestep = ifctimemeasure(value) + else: + self._timestep = value + return property(**locals()) + + @apply + def values(): + def fget( self ): + return self._values + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument values is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifctimeseriesvalue', scope = schema_scope)): + self._values = LIST(value) + else: + self._values = value + return property(**locals()) + +#################### + # ENTITY ifcdistributionport # +#################### +class ifcdistributionport(ifcport): + '''Entity ifcdistributionport definition. + + :param flowdirection + :type flowdirection:ifcflowdirectionenum + + :param predefinedtype + :type predefinedtype:ifcdistributionporttypeenum + + :param systemtype + :type systemtype:ifcdistributionsystemenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , flowdirection,predefinedtype,systemtype, ): + ifcport.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.flowdirection = flowdirection + self.predefinedtype = predefinedtype + self.systemtype = systemtype + + @apply + def flowdirection(): + def fget( self ): + return self._flowdirection + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcflowdirectionenum): + self._flowdirection = ifcflowdirectionenum(value) + else: + self._flowdirection = value + else: + self._flowdirection = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdistributionporttypeenum): + self._predefinedtype = ifcdistributionporttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def systemtype(): + def fget( self ): + return self._systemtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdistributionsystemenum): + self._systemtype = ifcdistributionsystemenum(value) + else: + self._systemtype = value + else: + self._systemtype = value + return property(**locals()) + +#################### + # ENTITY ifcreldefinesbytemplate # +#################### +class ifcreldefinesbytemplate(ifcreldefines): + '''Entity ifcreldefinesbytemplate definition. + + :param relatedpropertysets + :type relatedpropertysets:SET(1,None,'ifcpropertysetdefinition', scope = schema_scope) + + :param relatingtemplate + :type relatingtemplate:ifcpropertysettemplate + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedpropertysets,relatingtemplate, ): + ifcreldefines.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedpropertysets = relatedpropertysets + self.relatingtemplate = relatingtemplate + + @apply + def relatedpropertysets(): + def fget( self ): + return self._relatedpropertysets + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedpropertysets is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcpropertysetdefinition', scope = schema_scope)): + self._relatedpropertysets = SET(value) + else: + self._relatedpropertysets = value + return property(**locals()) + + @apply + def relatingtemplate(): + def fget( self ): + return self._relatingtemplate + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingtemplate is mantatory and can not be set to None') + if not check_type(value,ifcpropertysettemplate): + self._relatingtemplate = ifcpropertysettemplate(value) + else: + self._relatingtemplate = value + return property(**locals()) + +#################### + # ENTITY ifccartesianpointlist # +#################### +class ifccartesianpointlist(ifcgeometricrepresentationitem): + '''Entity ifccartesianpointlist definition. + ''' + def __init__( self , ): + ifcgeometricrepresentationitem.__init__(self , ) + +#################### + # ENTITY ifccartesianpointlist3d # +#################### +class ifccartesianpointlist3d(ifccartesianpointlist): + '''Entity ifccartesianpointlist3d definition. + + :param coordlist + :type coordlist:LIST(1,None,LIST(3,3,'REAL', scope = schema_scope)) + ''' + def __init__( self , coordlist, ): + ifccartesianpointlist.__init__(self , ) + self.coordlist = coordlist + + @apply + def coordlist(): + def fget( self ): + return self._coordlist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordlist is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,LIST(3,3,'REAL', scope = schema_scope))): + self._coordlist = LIST(value) + else: + self._coordlist = value + return property(**locals()) + +#################### + # ENTITY ifclightsourcepositional # +#################### +class ifclightsourcepositional(ifclightsource): + '''Entity ifclightsourcepositional definition. + + :param position + :type position:ifccartesianpoint + + :param radius + :type radius:ifcpositivelengthmeasure + + :param constantattenuation + :type constantattenuation:ifcreal + + :param distanceattenuation + :type distanceattenuation:ifcreal + + :param quadricattenuation + :type quadricattenuation:ifcreal + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , position,radius,constantattenuation,distanceattenuation,quadricattenuation, ): + ifclightsource.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ) + self.position = position + self.radius = radius + self.constantattenuation = constantattenuation + self.distanceattenuation = distanceattenuation + self.quadricattenuation = quadricattenuation + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._position = ifccartesianpoint(value) + else: + self._position = value + return property(**locals()) + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + + @apply + def constantattenuation(): + def fget( self ): + return self._constantattenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constantattenuation is mantatory and can not be set to None') + if not check_type(value,ifcreal): + self._constantattenuation = ifcreal(value) + else: + self._constantattenuation = value + return property(**locals()) + + @apply + def distanceattenuation(): + def fget( self ): + return self._distanceattenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distanceattenuation is mantatory and can not be set to None') + if not check_type(value,ifcreal): + self._distanceattenuation = ifcreal(value) + else: + self._distanceattenuation = value + return property(**locals()) + + @apply + def quadricattenuation(): + def fget( self ): + return self._quadricattenuation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument quadricattenuation is mantatory and can not be set to None') + if not check_type(value,ifcreal): + self._quadricattenuation = ifcreal(value) + else: + self._quadricattenuation = value + return property(**locals()) + +#################### + # ENTITY ifcpiletype # +#################### +class ifcpiletype(ifcbuildingelementtype): + '''Entity ifcpiletype definition. + + :param predefinedtype + :type predefinedtype:ifcpiletypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcpiletypeenum): + self._predefinedtype = ifcpiletypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcpiletypeenum.self.userdefined) or ((self.predefinedtype == ifcpiletypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccompositecurveonsurface # +#################### +class ifccompositecurveonsurface(ifccompositecurve): + '''Entity ifccompositecurveonsurface definition. + + :param basissurface + :type basissurface:SET(0,1,'ifcsurface', scope = schema_scope) + ''' + def __init__( self , inherited0__segments , inherited1__selfintersect , ): + ifccompositecurve.__init__(self , inherited0__segments , inherited1__selfintersect , ) + + @apply + def basissurface(): + def fget( self ): + attribute_eval = ifcgetbasissurface(self) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument basissurface is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def samesurface(self): + eval_samesurface_wr = (SIZEOF(self.basissurface) > 0) + if not eval_samesurface_wr: + raise AssertionError('Rule samesurface violated') + else: + return eval_samesurface_wr + + +#################### + # ENTITY ifcboundarycurve # +#################### +class ifcboundarycurve(ifccompositecurveonsurface): + '''Entity ifcboundarycurve definition. + ''' + def __init__( self , inherited0__segments , inherited1__selfintersect , ): + ifccompositecurveonsurface.__init__(self , inherited0__segments , inherited1__selfintersect , ) + def isclosed(self): + eval_isclosed_wr = self.self.ifccompositecurve.self.closedcurve + if not eval_isclosed_wr: + raise AssertionError('Rule isclosed violated') + else: + return eval_isclosed_wr + + +#################### + # ENTITY ifclightsourcedirectional # +#################### +class ifclightsourcedirectional(ifclightsource): + '''Entity ifclightsourcedirectional definition. + + :param orientation + :type orientation:ifcdirection + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , orientation, ): + ifclightsource.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ) + self.orientation = orientation + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._orientation = ifcdirection(value) + else: + self._orientation = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralpointreaction # +#################### +class ifcstructuralpointreaction(ifcstructuralreaction): + '''Entity ifcstructuralpointreaction definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ): + ifcstructuralreaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , ) + def suitableloadtype(self): + eval_suitableloadtype_wr = (SIZEOF(['IFC4.IFCSTRUCTURALLOADSINGLEFORCE','IFC4.IFCSTRUCTURALLOADSINGLEDISPLACEMENT'] * TYPEOF(self.self.ifcstructuralactivity.self.appliedload)) == 1) + if not eval_suitableloadtype_wr: + raise AssertionError('Rule suitableloadtype violated') + else: + return eval_suitableloadtype_wr + + +#################### + # ENTITY ifcstructurallinearaction # +#################### +class ifcstructurallinearaction(ifcstructuralcurveaction): + '''Entity ifcstructurallinearaction definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__projectedortrue , inherited11__predefinedtype , ): + ifcstructuralcurveaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__projectedortrue , inherited11__predefinedtype , ) + def suitableloadtype(self): + eval_suitableloadtype_wr = (SIZEOF(['IFC4.IFCSTRUCTURALLOADLINEARFORCE','IFC4.IFCSTRUCTURALLOADTEMPERATURE'] * TYPEOF(self.self.ifcstructuralactivity.self.appliedload)) == 1) + if not eval_suitableloadtype_wr: + raise AssertionError('Rule suitableloadtype violated') + else: + return eval_suitableloadtype_wr + + def constpredefinedtype(self): + eval_constpredefinedtype_wr = (self.self.ifcstructuralcurveaction.self.predefinedtype == ifcstructuralcurveactivitytypeenum.self.const) + if not eval_constpredefinedtype_wr: + raise AssertionError('Rule constpredefinedtype violated') + else: + return eval_constpredefinedtype_wr + + +#################### + # ENTITY ifcfastener # +#################### +class ifcfastener(ifcelementcomponent): + '''Entity ifcfastener definition. + + :param predefinedtype + :type predefinedtype:ifcfastenertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcfastenertypeenum): + self._predefinedtype = ifcfastenertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcfastenertypeenum.self.userdefined)) or ((self.predefinedtype == ifcfastenertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCFASTENERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcorientededge # +#################### +class ifcorientededge(ifcedge): + '''Entity ifcorientededge definition. + + :param edgeelement + :type edgeelement:ifcedge + + :param orientation + :type orientation:BOOLEAN + + :param ifcedge_edgestart + :type ifcedge_edgestart:ifcvertex + + :param ifcedge_edgeend + :type ifcedge_edgeend:ifcvertex + ''' + def __init__( self , inherited0__edgestart , inherited1__edgeend , edgeelement,orientation, ): + ifcedge.__init__(self , inherited0__edgestart , inherited1__edgeend , ) + self.edgeelement = edgeelement + self.orientation = orientation + + @apply + def edgeelement(): + def fget( self ): + return self._edgeelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgeelement is mantatory and can not be set to None') + if not check_type(value,ifcedge): + self._edgeelement = ifcedge(value) + else: + self._edgeelement = value + return property(**locals()) + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._orientation = BOOLEAN(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def ifcedge_edgestart(): + def fget( self ): + attribute_eval = ifcbooleanchoose(self.orientation,self.edgeelement.self.edgestart,self.edgeelement.self.edgeend) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcedge_edgestart is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ifcedge_edgeend(): + def fget( self ): + attribute_eval = ifcbooleanchoose(self.orientation,self.edgeelement.self.edgeend,self.edgeelement.self.edgestart) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcedge_edgeend is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def edgeelementnotoriented(self): + eval_edgeelementnotoriented_wr = ( not ('IFC4.IFCORIENTEDEDGE' == TYPEOF(self.edgeelement))) + if not eval_edgeelementnotoriented_wr: + raise AssertionError('Rule edgeelementnotoriented violated') + else: + return eval_edgeelementnotoriented_wr + + +#################### + # ENTITY ifcrelassociatesconstraint # +#################### +class ifcrelassociatesconstraint(ifcrelassociates): + '''Entity ifcrelassociatesconstraint definition. + + :param intent + :type intent:ifclabel + + :param relatingconstraint + :type relatingconstraint:ifcconstraint + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , intent,relatingconstraint, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.intent = intent + self.relatingconstraint = relatingconstraint + + @apply + def intent(): + def fget( self ): + return self._intent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._intent = ifclabel(value) + else: + self._intent = value + else: + self._intent = value + return property(**locals()) + + @apply + def relatingconstraint(): + def fget( self ): + return self._relatingconstraint + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingconstraint is mantatory and can not be set to None') + if not check_type(value,ifcconstraint): + self._relatingconstraint = ifcconstraint(value) + else: + self._relatingconstraint = value + return property(**locals()) + +#################### + # ENTITY ifctimeseriesvalue # +#################### +class ifctimeseriesvalue(BaseEntityClass): + '''Entity ifctimeseriesvalue definition. + + :param listvalues + :type listvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + ''' + def __init__( self , listvalues, ): + self.listvalues = listvalues + + @apply + def listvalues(): + def fget( self ): + return self._listvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument listvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._listvalues = LIST(value) + else: + self._listvalues = value + return property(**locals()) + +#################### + # ENTITY ifcbuildingelementpart # +#################### +class ifcbuildingelementpart(ifcelementcomponent): + '''Entity ifcbuildingelementpart definition. + + :param predefinedtype + :type predefinedtype:ifcbuildingelementparttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcbuildingelementparttypeenum): + self._predefinedtype = ifcbuildingelementparttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcbuildingelementparttypeenum.self.userdefined)) or ((self.predefinedtype == ifcbuildingelementparttypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCBUILDINGELEMENTPARTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcmaterialconstituentset # +#################### +class ifcmaterialconstituentset(ifcmaterialdefinition): + '''Entity ifcmaterialconstituentset definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param materialconstituents + :type materialconstituents:SET(1,None,'ifcmaterialconstituent', scope = schema_scope) + ''' + def __init__( self , name,description,materialconstituents, ): + ifcmaterialdefinition.__init__(self , ) + self.name = name + self.description = description + self.materialconstituents = materialconstituents + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def materialconstituents(): + def fget( self ): + return self._materialconstituents + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcmaterialconstituent', scope = schema_scope)): + self._materialconstituents = SET(value) + else: + self._materialconstituents = value + else: + self._materialconstituents = value + return property(**locals()) + +#################### + # ENTITY ifcbuildingelementproxy # +#################### +class ifcbuildingelementproxy(ifcbuildingelement): + '''Entity ifcbuildingelementproxy definition. + + :param predefinedtype + :type predefinedtype:ifcbuildingelementproxytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcbuildingelementproxytypeenum): + self._predefinedtype = ifcbuildingelementproxytypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def hasobjectname(self): + eval_hasobjectname_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_hasobjectname_wr: + raise AssertionError('Rule hasobjectname violated') + else: + return eval_hasobjectname_wr + + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcbuildingelementproxytypeenum.self.userdefined)) or ((self.predefinedtype == ifcbuildingelementproxytypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCBUILDINGELEMENTPROXYTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcdiscreteaccessorytype # +#################### +class ifcdiscreteaccessorytype(ifcelementcomponenttype): + '''Entity ifcdiscreteaccessorytype definition. + + :param predefinedtype + :type predefinedtype:ifcdiscreteaccessorytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcelementcomponenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcdiscreteaccessorytypeenum): + self._predefinedtype = ifcdiscreteaccessorytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcdiscreteaccessorytypeenum.self.userdefined) or ((self.predefinedtype == ifcdiscreteaccessorytypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcsurfacefeature # +#################### +class ifcsurfacefeature(ifcfeatureelement): + '''Entity ifcsurfacefeature definition. + + :param predefinedtype + :type predefinedtype:ifcsurfacefeaturetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcfeatureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsurfacefeaturetypeenum): + self._predefinedtype = ifcsurfacefeaturetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def hasobjecttype(self): + eval_hasobjecttype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcsurfacefeaturetypeenum.self.userdefined)) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + +#################### + # ENTITY ifcconnectedfaceset # +#################### +class ifcconnectedfaceset(ifctopologicalrepresentationitem): + '''Entity ifcconnectedfaceset definition. + + :param cfsfaces + :type cfsfaces:SET(1,None,'ifcface', scope = schema_scope) + ''' + def __init__( self , cfsfaces, ): + ifctopologicalrepresentationitem.__init__(self , ) + self.cfsfaces = cfsfaces + + @apply + def cfsfaces(): + def fget( self ): + return self._cfsfaces + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument cfsfaces is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcface', scope = schema_scope)): + self._cfsfaces = SET(value) + else: + self._cfsfaces = value + return property(**locals()) + +#################### + # ENTITY ifcclosedshell # +#################### +class ifcclosedshell(ifcconnectedfaceset): + '''Entity ifcclosedshell definition. + ''' + def __init__( self , inherited0__cfsfaces , ): + ifcconnectedfaceset.__init__(self , inherited0__cfsfaces , ) + +#################### + # ENTITY ifccooledbeam # +#################### +class ifccooledbeam(ifcenergyconversiondevice): + '''Entity ifccooledbeam definition. + + :param predefinedtype + :type predefinedtype:ifccooledbeamtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccooledbeamtypeenum): + self._predefinedtype = ifccooledbeamtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccooledbeamtypeenum.self.userdefined)) or ((self.predefinedtype == ifccooledbeamtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCOOLEDBEAMTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcmemberstandardcase # +#################### +class ifcmemberstandardcase(ifcmember): + '''Entity ifcmemberstandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ): + ifcmember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ) + def hasmaterialprofilesetusage(self): + eval_hasmaterialprofilesetusage_wr = (SIZEOF(None) == 1) + if not eval_hasmaterialprofilesetusage_wr: + raise AssertionError('Rule hasmaterialprofilesetusage violated') + else: + return eval_hasmaterialprofilesetusage_wr + + +#################### + # ENTITY ifcorganizationrelationship # +#################### +class ifcorganizationrelationship(ifcresourcelevelrelationship): + '''Entity ifcorganizationrelationship definition. + + :param relatingorganization + :type relatingorganization:ifcorganization + + :param relatedorganizations + :type relatedorganizations:SET(1,None,'ifcorganization', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , relatingorganization,relatedorganizations, ): + ifcresourcelevelrelationship.__init__(self , inherited0__name , inherited1__description , ) + self.relatingorganization = relatingorganization + self.relatedorganizations = relatedorganizations + + @apply + def relatingorganization(): + def fget( self ): + return self._relatingorganization + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingorganization is mantatory and can not be set to None') + if not check_type(value,ifcorganization): + self._relatingorganization = ifcorganization(value) + else: + self._relatingorganization = value + return property(**locals()) + + @apply + def relatedorganizations(): + def fget( self ): + return self._relatedorganizations + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedorganizations is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcorganization', scope = schema_scope)): + self._relatedorganizations = SET(value) + else: + self._relatedorganizations = value + return property(**locals()) + +#################### + # ENTITY ifcsanitaryterminal # +#################### +class ifcsanitaryterminal(ifcflowterminal): + '''Entity ifcsanitaryterminal definition. + + :param predefinedtype + :type predefinedtype:ifcsanitaryterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsanitaryterminaltypeenum): + self._predefinedtype = ifcsanitaryterminaltypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcsanitaryterminaltypeenum.self.userdefined)) or ((self.predefinedtype == ifcsanitaryterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSANITARYTERMINALTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcvibrationisolator # +#################### +class ifcvibrationisolator(ifcelementcomponent): + '''Entity ifcvibrationisolator definition. + + :param predefinedtype + :type predefinedtype:ifcvibrationisolatortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvibrationisolatortypeenum): + self._predefinedtype = ifcvibrationisolatortypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcvibrationisolatortypeenum.self.userdefined)) or ((self.predefinedtype == ifcvibrationisolatortypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCVIBRATIONISOLATORTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifccovering # +#################### +class ifccovering(ifcbuildingelement): + '''Entity ifccovering definition. + + :param predefinedtype + :type predefinedtype:ifccoveringtypeenum + + :param coversspaces + :type coversspaces:SET(0,1,'ifcrelcoversspaces', scope = schema_scope) + + :param coverselements + :type coverselements:SET(0,1,'ifcrelcoversbldgelements', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccoveringtypeenum): + self._predefinedtype = ifccoveringtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def coversspaces(): + def fget( self ): + return self._coversspaces + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument coversspaces is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def coverselements(): + def fget( self ): + return self._coverselements + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument coverselements is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccoveringtypeenum.self.userdefined)) or ((self.predefinedtype == ifccoveringtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCOVERINGTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcquantitytime # +#################### +class ifcquantitytime(ifcphysicalsimplequantity): + '''Entity ifcquantitytime definition. + + :param timevalue + :type timevalue:ifctimemeasure + + :param formula + :type formula:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , timevalue,formula, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.timevalue = timevalue + self.formula = formula + + @apply + def timevalue(): + def fget( self ): + return self._timevalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timevalue is mantatory and can not be set to None') + if not check_type(value,ifctimemeasure): + self._timevalue = ifctimemeasure(value) + else: + self._timevalue = value + return property(**locals()) + + @apply + def formula(): + def fget( self ): + return self._formula + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._formula = ifclabel(value) + else: + self._formula = value + else: + self._formula = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.timeunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.timevalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcdocumentinformationrelationship # +#################### +class ifcdocumentinformationrelationship(ifcresourcelevelrelationship): + '''Entity ifcdocumentinformationrelationship definition. + + :param relatingdocument + :type relatingdocument:ifcdocumentinformation + + :param relateddocuments + :type relateddocuments:SET(1,None,'ifcdocumentinformation', scope = schema_scope) + + :param relationshiptype + :type relationshiptype:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , relatingdocument,relateddocuments,relationshiptype, ): + ifcresourcelevelrelationship.__init__(self , inherited0__name , inherited1__description , ) + self.relatingdocument = relatingdocument + self.relateddocuments = relateddocuments + self.relationshiptype = relationshiptype + + @apply + def relatingdocument(): + def fget( self ): + return self._relatingdocument + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingdocument is mantatory and can not be set to None') + if not check_type(value,ifcdocumentinformation): + self._relatingdocument = ifcdocumentinformation(value) + else: + self._relatingdocument = value + return property(**locals()) + + @apply + def relateddocuments(): + def fget( self ): + return self._relateddocuments + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relateddocuments is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcdocumentinformation', scope = schema_scope)): + self._relateddocuments = SET(value) + else: + self._relateddocuments = value + return property(**locals()) + + @apply + def relationshiptype(): + def fget( self ): + return self._relationshiptype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._relationshiptype = ifclabel(value) + else: + self._relationshiptype = value + else: + self._relationshiptype = value + return property(**locals()) + +#################### + # ENTITY ifcgeometricrepresentationsubcontext # +#################### +class ifcgeometricrepresentationsubcontext(ifcgeometricrepresentationcontext): + '''Entity ifcgeometricrepresentationsubcontext definition. + + :param parentcontext + :type parentcontext:ifcgeometricrepresentationcontext + + :param targetscale + :type targetscale:ifcpositiveratiomeasure + + :param targetview + :type targetview:ifcgeometricprojectionenum + + :param userdefinedtargetview + :type userdefinedtargetview:ifclabel + + :param ifcgeometricrepresentationcontext_worldcoordinatesystem + :type ifcgeometricrepresentationcontext_worldcoordinatesystem:ifcaxis2placement + + :param ifcgeometricrepresentationcontext_coordinatespacedimension + :type ifcgeometricrepresentationcontext_coordinatespacedimension:ifcdimensioncount + + :param ifcgeometricrepresentationcontext_truenorth + :type ifcgeometricrepresentationcontext_truenorth:ifcdirection + + :param ifcgeometricrepresentationcontext_precision + :type ifcgeometricrepresentationcontext_precision:REAL + ''' + def __init__( self , inherited0__contextidentifier , inherited1__contexttype , inherited2__coordinatespacedimension , inherited3__precision , inherited4__worldcoordinatesystem , inherited5__truenorth , parentcontext,targetscale,targetview,userdefinedtargetview, ): + ifcgeometricrepresentationcontext.__init__(self , inherited0__contextidentifier , inherited1__contexttype , inherited2__coordinatespacedimension , inherited3__precision , inherited4__worldcoordinatesystem , inherited5__truenorth , ) + self.parentcontext = parentcontext + self.targetscale = targetscale + self.targetview = targetview + self.userdefinedtargetview = userdefinedtargetview + + @apply + def parentcontext(): + def fget( self ): + return self._parentcontext + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parentcontext is mantatory and can not be set to None') + if not check_type(value,ifcgeometricrepresentationcontext): + self._parentcontext = ifcgeometricrepresentationcontext(value) + else: + self._parentcontext = value + return property(**locals()) + + @apply + def targetscale(): + def fget( self ): + return self._targetscale + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._targetscale = ifcpositiveratiomeasure(value) + else: + self._targetscale = value + else: + self._targetscale = value + return property(**locals()) + + @apply + def targetview(): + def fget( self ): + return self._targetview + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument targetview is mantatory and can not be set to None') + if not check_type(value,ifcgeometricprojectionenum): + self._targetview = ifcgeometricprojectionenum(value) + else: + self._targetview = value + return property(**locals()) + + @apply + def userdefinedtargetview(): + def fget( self ): + return self._userdefinedtargetview + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._userdefinedtargetview = ifclabel(value) + else: + self._userdefinedtargetview = value + else: + self._userdefinedtargetview = value + return property(**locals()) + + @apply + def ifcgeometricrepresentationcontext_worldcoordinatesystem(): + def fget( self ): + attribute_eval = self.parentcontext.self.worldcoordinatesystem + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcgeometricrepresentationcontext_worldcoordinatesystem is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ifcgeometricrepresentationcontext_coordinatespacedimension(): + def fget( self ): + attribute_eval = self.parentcontext.self.coordinatespacedimension + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcgeometricrepresentationcontext_coordinatespacedimension is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ifcgeometricrepresentationcontext_truenorth(): + def fget( self ): + attribute_eval = NVL(self.parentcontext.self.truenorth,ifcconvertdirectioninto2d(self.self.ifcgeometricrepresentationcontext.self.worldcoordinatesystem.self.p[2])) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcgeometricrepresentationcontext_truenorth is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def ifcgeometricrepresentationcontext_precision(): + def fget( self ): + attribute_eval = NVL(self.parentcontext.self.precision,1e-005) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcgeometricrepresentationcontext_precision is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def wr31(self): + eval_wr31_wr = ( not ('IFC4.IFCGEOMETRICREPRESENTATIONSUBCONTEXT' == TYPEOF(self.parentcontext))) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + def wr32(self): + eval_wr32_wr = ((self.targetview != ifcgeometricprojectionenum.self.userdefined) or ((self.targetview == ifcgeometricprojectionenum.self.userdefined) and EXISTS(self.userdefinedtargetview))) + if not eval_wr32_wr: + raise AssertionError('Rule wr32 violated') + else: + return eval_wr32_wr + + +#################### + # ENTITY ifccommunicationsappliancetype # +#################### +class ifccommunicationsappliancetype(ifcflowterminaltype): + '''Entity ifccommunicationsappliancetype definition. + + :param predefinedtype + :type predefinedtype:ifccommunicationsappliancetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccommunicationsappliancetypeenum): + self._predefinedtype = ifccommunicationsappliancetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccommunicationsappliancetypeenum.self.userdefined) or ((self.predefinedtype == ifccommunicationsappliancetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcdocumentreference # +#################### +class ifcdocumentreference(ifcexternalreference): + '''Entity ifcdocumentreference definition. + + :param description + :type description:ifctext + + :param referenceddocument + :type referenceddocument:ifcdocumentinformation + + :param documentrefforobjects + :type documentrefforobjects:SET(0,None,'ifcrelassociatesdocument', scope = schema_scope) + ''' + def __init__( self , inherited0__location , inherited1__identification , inherited2__name , description,referenceddocument, ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__identification , inherited2__name , ) + self.description = description + self.referenceddocument = referenceddocument + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def referenceddocument(): + def fget( self ): + return self._referenceddocument + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdocumentinformation): + self._referenceddocument = ifcdocumentinformation(value) + else: + self._referenceddocument = value + else: + self._referenceddocument = value + return property(**locals()) + + @apply + def documentrefforobjects(): + def fget( self ): + return self._documentrefforobjects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument documentrefforobjects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def wr1(self): + eval_wr1_wr = (EXISTS(self.name) XOR EXISTS(self.referenceddocument)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcexternallydefinedtextfont # +#################### +class ifcexternallydefinedtextfont(ifcexternalreference): + '''Entity ifcexternallydefinedtextfont definition. + ''' + def __init__( self , inherited0__location , inherited1__identification , inherited2__name , ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__identification , inherited2__name , ) + +#################### + # ENTITY ifcconnectioncurvegeometry # +#################### +class ifcconnectioncurvegeometry(ifcconnectiongeometry): + '''Entity ifcconnectioncurvegeometry definition. + + :param curveonrelatingelement + :type curveonrelatingelement:ifccurveoredgecurve + + :param curveonrelatedelement + :type curveonrelatedelement:ifccurveoredgecurve + ''' + def __init__( self , curveonrelatingelement,curveonrelatedelement, ): + ifcconnectiongeometry.__init__(self , ) + self.curveonrelatingelement = curveonrelatingelement + self.curveonrelatedelement = curveonrelatedelement + + @apply + def curveonrelatingelement(): + def fget( self ): + return self._curveonrelatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument curveonrelatingelement is mantatory and can not be set to None') + if not check_type(value,ifccurveoredgecurve): + self._curveonrelatingelement = ifccurveoredgecurve(value) + else: + self._curveonrelatingelement = value + return property(**locals()) + + @apply + def curveonrelatedelement(): + def fget( self ): + return self._curveonrelatedelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccurveoredgecurve): + self._curveonrelatedelement = ifccurveoredgecurve(value) + else: + self._curveonrelatedelement = value + else: + self._curveonrelatedelement = value + return property(**locals()) + +#################### + # ENTITY ifcengine # +#################### +class ifcengine(ifcenergyconversiondevice): + '''Entity ifcengine definition. + + :param predefinedtype + :type predefinedtype:ifcenginetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcenginetypeenum): + self._predefinedtype = ifcenginetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcenginetypeenum.self.userdefined)) or ((self.predefinedtype == ifcenginetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCENGINETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcresourcetime # +#################### +class ifcresourcetime(ifcschedulingtime): + '''Entity ifcresourcetime definition. + + :param schedulework + :type schedulework:ifcduration + + :param scheduleusage + :type scheduleusage:ifcpositiveratiomeasure + + :param schedulestart + :type schedulestart:ifcdatetime + + :param schedulefinish + :type schedulefinish:ifcdatetime + + :param schedulecontour + :type schedulecontour:ifclabel + + :param levelingdelay + :type levelingdelay:ifcduration + + :param isoverallocated + :type isoverallocated:BOOLEAN + + :param statustime + :type statustime:ifcdatetime + + :param actualwork + :type actualwork:ifcduration + + :param actualusage + :type actualusage:ifcpositiveratiomeasure + + :param actualstart + :type actualstart:ifcdatetime + + :param actualfinish + :type actualfinish:ifcdatetime + + :param remainingwork + :type remainingwork:ifcduration + + :param remainingusage + :type remainingusage:ifcpositiveratiomeasure + + :param completion + :type completion:ifcpositiveratiomeasure + ''' + def __init__( self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , schedulework,scheduleusage,schedulestart,schedulefinish,schedulecontour,levelingdelay,isoverallocated,statustime,actualwork,actualusage,actualstart,actualfinish,remainingwork,remainingusage,completion, ): + ifcschedulingtime.__init__(self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , ) + self.schedulework = schedulework + self.scheduleusage = scheduleusage + self.schedulestart = schedulestart + self.schedulefinish = schedulefinish + self.schedulecontour = schedulecontour + self.levelingdelay = levelingdelay + self.isoverallocated = isoverallocated + self.statustime = statustime + self.actualwork = actualwork + self.actualusage = actualusage + self.actualstart = actualstart + self.actualfinish = actualfinish + self.remainingwork = remainingwork + self.remainingusage = remainingusage + self.completion = completion + + @apply + def schedulework(): + def fget( self ): + return self._schedulework + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._schedulework = ifcduration(value) + else: + self._schedulework = value + else: + self._schedulework = value + return property(**locals()) + + @apply + def scheduleusage(): + def fget( self ): + return self._scheduleusage + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._scheduleusage = ifcpositiveratiomeasure(value) + else: + self._scheduleusage = value + else: + self._scheduleusage = value + return property(**locals()) + + @apply + def schedulestart(): + def fget( self ): + return self._schedulestart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._schedulestart = ifcdatetime(value) + else: + self._schedulestart = value + else: + self._schedulestart = value + return property(**locals()) + + @apply + def schedulefinish(): + def fget( self ): + return self._schedulefinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._schedulefinish = ifcdatetime(value) + else: + self._schedulefinish = value + else: + self._schedulefinish = value + return property(**locals()) + + @apply + def schedulecontour(): + def fget( self ): + return self._schedulecontour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._schedulecontour = ifclabel(value) + else: + self._schedulecontour = value + else: + self._schedulecontour = value + return property(**locals()) + + @apply + def levelingdelay(): + def fget( self ): + return self._levelingdelay + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._levelingdelay = ifcduration(value) + else: + self._levelingdelay = value + else: + self._levelingdelay = value + return property(**locals()) + + @apply + def isoverallocated(): + def fget( self ): + return self._isoverallocated + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._isoverallocated = BOOLEAN(value) + else: + self._isoverallocated = value + else: + self._isoverallocated = value + return property(**locals()) + + @apply + def statustime(): + def fget( self ): + return self._statustime + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._statustime = ifcdatetime(value) + else: + self._statustime = value + else: + self._statustime = value + return property(**locals()) + + @apply + def actualwork(): + def fget( self ): + return self._actualwork + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._actualwork = ifcduration(value) + else: + self._actualwork = value + else: + self._actualwork = value + return property(**locals()) + + @apply + def actualusage(): + def fget( self ): + return self._actualusage + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._actualusage = ifcpositiveratiomeasure(value) + else: + self._actualusage = value + else: + self._actualusage = value + return property(**locals()) + + @apply + def actualstart(): + def fget( self ): + return self._actualstart + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._actualstart = ifcdatetime(value) + else: + self._actualstart = value + else: + self._actualstart = value + return property(**locals()) + + @apply + def actualfinish(): + def fget( self ): + return self._actualfinish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._actualfinish = ifcdatetime(value) + else: + self._actualfinish = value + else: + self._actualfinish = value + return property(**locals()) + + @apply + def remainingwork(): + def fget( self ): + return self._remainingwork + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcduration): + self._remainingwork = ifcduration(value) + else: + self._remainingwork = value + else: + self._remainingwork = value + return property(**locals()) + + @apply + def remainingusage(): + def fget( self ): + return self._remainingusage + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._remainingusage = ifcpositiveratiomeasure(value) + else: + self._remainingusage = value + else: + self._remainingusage = value + return property(**locals()) + + @apply + def completion(): + def fget( self ): + return self._completion + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositiveratiomeasure): + self._completion = ifcpositiveratiomeasure(value) + else: + self._completion = value + else: + self._completion = value + return property(**locals()) + +#################### + # ENTITY ifccrewresourcetype # +#################### +class ifccrewresourcetype(ifcconstructionresourcetype): + '''Entity ifccrewresourcetype definition. + + :param predefinedtype + :type predefinedtype:ifccrewresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , predefinedtype, ): + ifcconstructionresourcetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccrewresourcetypeenum): + self._predefinedtype = ifccrewresourcetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccrewresourcetypeenum.self.userdefined) or ((self.predefinedtype == ifccrewresourcetypeenum.self.userdefined) and EXISTS(self.self.ifctyperesource.self.resourcetype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcdraughtingpredefinedcolour # +#################### +class ifcdraughtingpredefinedcolour(ifcpredefinedcolour): + '''Entity ifcdraughtingpredefinedcolour definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefinedcolour.__init__(self , inherited0__name , ) + def predefinedcolournames(self): + eval_predefinedcolournames_wr = (self.self.ifcpredefineditem.self.name == ['black','red','green','blue','yellow','magenta','cyan','white','by layer']) + if not eval_predefinedcolournames_wr: + raise AssertionError('Rule predefinedcolournames violated') + else: + return eval_predefinedcolournames_wr + + +#################### + # ENTITY ifcrelcoversspaces # +#################### +class ifcrelcoversspaces(ifcrelconnects): + '''Entity ifcrelcoversspaces definition. + + :param relatingspace + :type relatingspace:ifcspace + + :param relatedcoverings + :type relatedcoverings:SET(1,None,'ifccovering', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingspace,relatedcoverings, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingspace = relatingspace + self.relatedcoverings = relatedcoverings + + @apply + def relatingspace(): + def fget( self ): + return self._relatingspace + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingspace is mantatory and can not be set to None') + if not check_type(value,ifcspace): + self._relatingspace = ifcspace(value) + else: + self._relatingspace = value + return property(**locals()) + + @apply + def relatedcoverings(): + def fget( self ): + return self._relatedcoverings + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedcoverings is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifccovering', scope = schema_scope)): + self._relatedcoverings = SET(value) + else: + self._relatedcoverings = value + return property(**locals()) + +#################### + # ENTITY ifclaborresource # +#################### +class ifclaborresource(ifcconstructionresource): + '''Entity ifclaborresource definition. + + :param predefinedtype + :type predefinedtype:ifclaborresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , predefinedtype, ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclaborresourcetypeenum): + self._predefinedtype = ifclaborresourcetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifclaborresourcetypeenum.self.userdefined)) or ((self.predefinedtype == ifclaborresourcetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcmechanicalfastenertype # +#################### +class ifcmechanicalfastenertype(ifcelementcomponenttype): + '''Entity ifcmechanicalfastenertype definition. + + :param predefinedtype + :type predefinedtype:ifcmechanicalfastenertypeenum + + :param nominaldiameter + :type nominaldiameter:ifcpositivelengthmeasure + + :param nominallength + :type nominallength:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype,nominaldiameter,nominallength, ): + ifcelementcomponenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + self.nominaldiameter = nominaldiameter + self.nominallength = nominallength + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcmechanicalfastenertypeenum): + self._predefinedtype = ifcmechanicalfastenertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def nominaldiameter(): + def fget( self ): + return self._nominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominaldiameter = ifcpositivelengthmeasure(value) + else: + self._nominaldiameter = value + else: + self._nominaldiameter = value + return property(**locals()) + + @apply + def nominallength(): + def fget( self ): + return self._nominallength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominallength = ifcpositivelengthmeasure(value) + else: + self._nominallength = value + else: + self._nominallength = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcmechanicalfastenertypeenum.self.userdefined) or ((self.predefinedtype == ifcmechanicalfastenertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcquantityweight # +#################### +class ifcquantityweight(ifcphysicalsimplequantity): + '''Entity ifcquantityweight definition. + + :param weightvalue + :type weightvalue:ifcmassmeasure + + :param formula + :type formula:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , weightvalue,formula, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.weightvalue = weightvalue + self.formula = formula + + @apply + def weightvalue(): + def fget( self ): + return self._weightvalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument weightvalue is mantatory and can not be set to None') + if not check_type(value,ifcmassmeasure): + self._weightvalue = ifcmassmeasure(value) + else: + self._weightvalue = value + return property(**locals()) + + @apply + def formula(): + def fget( self ): + return self._formula + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._formula = ifclabel(value) + else: + self._formula = value + else: + self._formula = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.massunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.weightvalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcwalltype # +#################### +class ifcwalltype(ifcbuildingelementtype): + '''Entity ifcwalltype definition. + + :param predefinedtype + :type predefinedtype:ifcwalltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcwalltypeenum): + self._predefinedtype = ifcwalltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcwalltypeenum.self.userdefined) or ((self.predefinedtype == ifcwalltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcconstructionmaterialresource # +#################### +class ifcconstructionmaterialresource(ifcconstructionresource): + '''Entity ifcconstructionmaterialresource definition. + + :param predefinedtype + :type predefinedtype:ifcconstructionmaterialresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , predefinedtype, ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcconstructionmaterialresourcetypeenum): + self._predefinedtype = ifcconstructionmaterialresourcetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcconstructionmaterialresourcetypeenum.self.userdefined)) or ((self.predefinedtype == ifcconstructionmaterialresourcetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcapprovalrelationship # +#################### +class ifcapprovalrelationship(ifcresourcelevelrelationship): + '''Entity ifcapprovalrelationship definition. + + :param relatingapproval + :type relatingapproval:ifcapproval + + :param relatedapprovals + :type relatedapprovals:SET(1,None,'ifcapproval', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , relatingapproval,relatedapprovals, ): + ifcresourcelevelrelationship.__init__(self , inherited0__name , inherited1__description , ) + self.relatingapproval = relatingapproval + self.relatedapprovals = relatedapprovals + + @apply + def relatingapproval(): + def fget( self ): + return self._relatingapproval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingapproval is mantatory and can not be set to None') + if not check_type(value,ifcapproval): + self._relatingapproval = ifcapproval(value) + else: + self._relatingapproval = value + return property(**locals()) + + @apply + def relatedapprovals(): + def fget( self ): + return self._relatedapprovals + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedapprovals is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcapproval', scope = schema_scope)): + self._relatedapprovals = SET(value) + else: + self._relatedapprovals = value + return property(**locals()) + +#################### + # ENTITY ifcboundingbox # +#################### +class ifcboundingbox(ifcgeometricrepresentationitem): + '''Entity ifcboundingbox definition. + + :param corner + :type corner:ifccartesianpoint + + :param xdim + :type xdim:ifcpositivelengthmeasure + + :param ydim + :type ydim:ifcpositivelengthmeasure + + :param zdim + :type zdim:ifcpositivelengthmeasure + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , corner,xdim,ydim,zdim, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.corner = corner + self.xdim = xdim + self.ydim = ydim + self.zdim = zdim + + @apply + def corner(): + def fget( self ): + return self._corner + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument corner is mantatory and can not be set to None') + if not check_type(value,ifccartesianpoint): + self._corner = ifccartesianpoint(value) + else: + self._corner = value + return property(**locals()) + + @apply + def xdim(): + def fget( self ): + return self._xdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument xdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._xdim = ifcpositivelengthmeasure(value) + else: + self._xdim = value + return property(**locals()) + + @apply + def ydim(): + def fget( self ): + return self._ydim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ydim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ydim = ifcpositivelengthmeasure(value) + else: + self._ydim = value + return property(**locals()) + + @apply + def zdim(): + def fget( self ): + return self._zdim + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument zdim is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._zdim = ifcpositivelengthmeasure(value) + else: + self._zdim = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcishapeprofiledef # +#################### +class ifcishapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifcishapeprofiledef definition. + + :param overallwidth + :type overallwidth:ifcpositivelengthmeasure + + :param overalldepth + :type overalldepth:ifcpositivelengthmeasure + + :param webthickness + :type webthickness:ifcpositivelengthmeasure + + :param flangethickness + :type flangethickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcnonnegativelengthmeasure + + :param flangeedgeradius + :type flangeedgeradius:ifcnonnegativelengthmeasure + + :param flangeslope + :type flangeslope:ifcplaneanglemeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , overallwidth,overalldepth,webthickness,flangethickness,filletradius,flangeedgeradius,flangeslope, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.overallwidth = overallwidth + self.overalldepth = overalldepth + self.webthickness = webthickness + self.flangethickness = flangethickness + self.filletradius = filletradius + self.flangeedgeradius = flangeedgeradius + self.flangeslope = flangeslope + + @apply + def overallwidth(): + def fget( self ): + return self._overallwidth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument overallwidth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._overallwidth = ifcpositivelengthmeasure(value) + else: + self._overallwidth = value + return property(**locals()) + + @apply + def overalldepth(): + def fget( self ): + return self._overalldepth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument overalldepth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._overalldepth = ifcpositivelengthmeasure(value) + else: + self._overalldepth = value + return property(**locals()) + + @apply + def webthickness(): + def fget( self ): + return self._webthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument webthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._webthickness = ifcpositivelengthmeasure(value) + else: + self._webthickness = value + return property(**locals()) + + @apply + def flangethickness(): + def fget( self ): + return self._flangethickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument flangethickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._flangethickness = ifcpositivelengthmeasure(value) + else: + self._flangethickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._filletradius = ifcnonnegativelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + + @apply + def flangeedgeradius(): + def fget( self ): + return self._flangeedgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._flangeedgeradius = ifcnonnegativelengthmeasure(value) + else: + self._flangeedgeradius = value + else: + self._flangeedgeradius = value + return property(**locals()) + + @apply + def flangeslope(): + def fget( self ): + return self._flangeslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._flangeslope = ifcplaneanglemeasure(value) + else: + self._flangeslope = value + else: + self._flangeslope = value + return property(**locals()) + def validflangethickness(self): + eval_validflangethickness_wr = ((2 * self.flangethickness) < self.overalldepth) + if not eval_validflangethickness_wr: + raise AssertionError('Rule validflangethickness violated') + else: + return eval_validflangethickness_wr + + def validwebthickness(self): + eval_validwebthickness_wr = (self.webthickness < self.overallwidth) + if not eval_validwebthickness_wr: + raise AssertionError('Rule validwebthickness violated') + else: + return eval_validwebthickness_wr + + def validfilletradius(self): + eval_validfilletradius_wr = (( not EXISTS(self.filletradius)) or ((self.filletradius <= ((self.overallwidth - self.webthickness) / 2)) and (self.filletradius <= ((self.overalldepth - (2 * self.flangethickness)) / 2)))) + if not eval_validfilletradius_wr: + raise AssertionError('Rule validfilletradius violated') + else: + return eval_validfilletradius_wr + + +#################### + # ENTITY ifctextstylefordefinedfont # +#################### +class ifctextstylefordefinedfont(ifcpresentationitem): + '''Entity ifctextstylefordefinedfont definition. + + :param colour + :type colour:ifccolour + + :param backgroundcolour + :type backgroundcolour:ifccolour + ''' + def __init__( self , colour,backgroundcolour, ): + ifcpresentationitem.__init__(self , ) + self.colour = colour + self.backgroundcolour = backgroundcolour + + @apply + def colour(): + def fget( self ): + return self._colour + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colour is mantatory and can not be set to None') + if not check_type(value,ifccolour): + self._colour = ifccolour(value) + else: + self._colour = value + return property(**locals()) + + @apply + def backgroundcolour(): + def fget( self ): + return self._backgroundcolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolour): + self._backgroundcolour = ifccolour(value) + else: + self._backgroundcolour = value + else: + self._backgroundcolour = value + return property(**locals()) + +#################### + # ENTITY ifcconstructionproductresource # +#################### +class ifcconstructionproductresource(ifcconstructionresource): + '''Entity ifcconstructionproductresource definition. + + :param predefinedtype + :type predefinedtype:ifcconstructionproductresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , predefinedtype, ): + ifcconstructionresource.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , inherited7__usage , inherited8__basecosts , inherited9__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcconstructionproductresourcetypeenum): + self._predefinedtype = ifcconstructionproductresourcetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcconstructionproductresourcetypeenum.self.userdefined)) or ((self.predefinedtype == ifcconstructionproductresourcetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcmonetaryunit # +#################### +class ifcmonetaryunit(BaseEntityClass): + '''Entity ifcmonetaryunit definition. + + :param currency + :type currency:ifclabel + ''' + def __init__( self , currency, ): + self.currency = currency + + @apply + def currency(): + def fget( self ): + return self._currency + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument currency is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._currency = ifclabel(value) + else: + self._currency = value + return property(**locals()) + +#################### + # ENTITY ifcpropertysinglevalue # +#################### +class ifcpropertysinglevalue(ifcsimpleproperty): + '''Entity ifcpropertysinglevalue definition. + + :param nominalvalue + :type nominalvalue:ifcvalue + + :param unit + :type unit:ifcunit + ''' + def __init__( self , inherited0__name , inherited1__description , nominalvalue,unit, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.nominalvalue = nominalvalue + self.unit = unit + + @apply + def nominalvalue(): + def fget( self ): + return self._nominalvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcvalue): + self._nominalvalue = ifcvalue(value) + else: + self._nominalvalue = value + else: + self._nominalvalue = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + +#################### + # ENTITY ifcrelassignstoprocess # +#################### +class ifcrelassignstoprocess(ifcrelassigns): + '''Entity ifcrelassignstoprocess definition. + + :param relatingprocess + :type relatingprocess:ifcprocessselect + + :param quantityinprocess + :type quantityinprocess:ifcmeasurewithunit + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingprocess,quantityinprocess, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingprocess = relatingprocess + self.quantityinprocess = quantityinprocess + + @apply + def relatingprocess(): + def fget( self ): + return self._relatingprocess + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingprocess is mantatory and can not be set to None') + if not check_type(value,ifcprocessselect): + self._relatingprocess = ifcprocessselect(value) + else: + self._relatingprocess = value + return property(**locals()) + + @apply + def quantityinprocess(): + def fget( self ): + return self._quantityinprocess + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmeasurewithunit): + self._quantityinprocess = ifcmeasurewithunit(value) + else: + self._quantityinprocess = value + else: + self._quantityinprocess = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcsiunit # +#################### +class ifcsiunit(ifcnamedunit): + '''Entity ifcsiunit definition. + + :param prefix + :type prefix:ifcsiprefix + + :param name + :type name:ifcsiunitname + + :param ifcnamedunit_dimensions + :type ifcnamedunit_dimensions:ifcdimensionalexponents + ''' + def __init__( self , inherited0__dimensions , inherited1__unittype , prefix,name, ): + ifcnamedunit.__init__(self , inherited0__dimensions , inherited1__unittype , ) + self.prefix = prefix + self.name = name + + @apply + def prefix(): + def fget( self ): + return self._prefix + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsiprefix): + self._prefix = ifcsiprefix(value) + else: + self._prefix = value + else: + self._prefix = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifcsiunitname): + self._name = ifcsiunitname(value) + else: + self._name = value + return property(**locals()) + + @apply + def ifcnamedunit_dimensions(): + def fget( self ): + attribute_eval = ifcdimensionsforsiunit(self.self.name) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ifcnamedunit_dimensions is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcspaceheatertype # +#################### +class ifcspaceheatertype(ifcflowterminaltype): + '''Entity ifcspaceheatertype definition. + + :param predefinedtype + :type predefinedtype:ifcspaceheatertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcspaceheatertypeenum): + self._predefinedtype = ifcspaceheatertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcspaceheatertypeenum.self.userdefined) or ((self.predefinedtype == ifcspaceheatertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcsubcontractresourcetype # +#################### +class ifcsubcontractresourcetype(ifcconstructionresourcetype): + '''Entity ifcsubcontractresourcetype definition. + + :param predefinedtype + :type predefinedtype:ifcsubcontractresourcetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , predefinedtype, ): + ifcconstructionresourcetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__resourcetype , inherited9__basecosts , inherited10__basequantity , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcsubcontractresourcetypeenum): + self._predefinedtype = ifcsubcontractresourcetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcsubcontractresourcetypeenum.self.userdefined) or ((self.predefinedtype == ifcsubcontractresourcetypeenum.self.userdefined) and EXISTS(self.self.ifctyperesource.self.resourcetype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcdistributionchamberelementtype # +#################### +class ifcdistributionchamberelementtype(ifcdistributionflowelementtype): + '''Entity ifcdistributionchamberelementtype definition. + + :param predefinedtype + :type predefinedtype:ifcdistributionchamberelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributionflowelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcdistributionchamberelementtypeenum): + self._predefinedtype = ifcdistributionchamberelementtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcdistributionchamberelementtypeenum.self.userdefined) or ((self.predefinedtype == ifcdistributionchamberelementtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcstructuralcurvemember # +#################### +class ifcstructuralcurvemember(ifcstructuralmember): + '''Entity ifcstructuralcurvemember definition. + + :param predefinedtype + :type predefinedtype:ifcstructuralcurvemembertypeenum + + :param axis + :type axis:ifcdirection + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , predefinedtype,axis, ): + ifcstructuralmember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.predefinedtype = predefinedtype + self.axis = axis + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstructuralcurvemembertypeenum): + self._predefinedtype = ifcstructuralcurvemembertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def axis(): + def fget( self ): + return self._axis + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument axis is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._axis = ifcdirection(value) + else: + self._axis = value + return property(**locals()) + def hasobjecttype(self): + eval_hasobjecttype_wr = ((self.predefinedtype != ifcstructuralcurvemembertypeenum.self.userdefined) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + +#################### + # ENTITY ifcjunctionboxtype # +#################### +class ifcjunctionboxtype(ifcflowfittingtype): + '''Entity ifcjunctionboxtype definition. + + :param predefinedtype + :type predefinedtype:ifcjunctionboxtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowfittingtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcjunctionboxtypeenum): + self._predefinedtype = ifcjunctionboxtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcjunctionboxtypeenum.self.userdefined) or ((self.predefinedtype == ifcjunctionboxtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccontextdependentunit # +#################### +class ifccontextdependentunit(ifcnamedunit): + '''Entity ifccontextdependentunit definition. + + :param name + :type name:ifclabel + + :param hasexternalreference + :type hasexternalreference:SET(0,None,'ifcexternalreferencerelationship', scope = schema_scope) + ''' + def __init__( self , inherited0__dimensions , inherited1__unittype , name, ): + ifcnamedunit.__init__(self , inherited0__dimensions , inherited1__unittype , ) + self.name = name + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def hasexternalreference(): + def fget( self ): + return self._hasexternalreference + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasexternalreference is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcsectionproperties # +#################### +class ifcsectionproperties(ifcpredefinedproperties): + '''Entity ifcsectionproperties definition. + + :param sectiontype + :type sectiontype:ifcsectiontypeenum + + :param startprofile + :type startprofile:ifcprofiledef + + :param endprofile + :type endprofile:ifcprofiledef + ''' + def __init__( self , sectiontype,startprofile,endprofile, ): + ifcpredefinedproperties.__init__(self , ) + self.sectiontype = sectiontype + self.startprofile = startprofile + self.endprofile = endprofile + + @apply + def sectiontype(): + def fget( self ): + return self._sectiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sectiontype is mantatory and can not be set to None') + if not check_type(value,ifcsectiontypeenum): + self._sectiontype = ifcsectiontypeenum(value) + else: + self._sectiontype = value + return property(**locals()) + + @apply + def startprofile(): + def fget( self ): + return self._startprofile + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument startprofile is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._startprofile = ifcprofiledef(value) + else: + self._startprofile = value + return property(**locals()) + + @apply + def endprofile(): + def fget( self ): + return self._endprofile + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcprofiledef): + self._endprofile = ifcprofiledef(value) + else: + self._endprofile = value + else: + self._endprofile = value + return property(**locals()) + +#################### + # ENTITY ifcshaperepresentation # +#################### +class ifcshaperepresentation(ifcshapemodel): + '''Entity ifcshaperepresentation definition. + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcshapemodel.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + def wr21(self): + eval_wr21_wr = ('IFC4.IFCGEOMETRICREPRESENTATIONCONTEXT' == TYPEOF(self.self.ifcrepresentation.self.contextofitems)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (SIZEOF(None) == 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + def wr23(self): + eval_wr23_wr = EXISTS(self.self.ifcrepresentation.self.representationtype) + if not eval_wr23_wr: + raise AssertionError('Rule wr23 violated') + else: + return eval_wr23_wr + + def wr24(self): + eval_wr24_wr = ifcshaperepresentationtypes(self.self.ifcrepresentation.self.representationtype,self.self.ifcrepresentation.self.items) + if not eval_wr24_wr: + raise AssertionError('Rule wr24 violated') + else: + return eval_wr24_wr + + +#################### + # ENTITY ifctriangulatedfaceset # +#################### +class ifctriangulatedfaceset(ifctessellatedfaceset): + '''Entity ifctriangulatedfaceset definition. + + :param coordindex + :type coordindex:LIST(1,None,LIST(3,3,'INTEGER', scope = schema_scope)) + + :param normalindex + :type normalindex:LIST(1,None,LIST(3,3,'INTEGER', scope = schema_scope)) + + :param numberoftriangles + :type numberoftriangles:INTEGER + ''' + def __init__( self , inherited0__coordinates , inherited1__normals , inherited2__closed , coordindex,normalindex, ): + ifctessellatedfaceset.__init__(self , inherited0__coordinates , inherited1__normals , inherited2__closed , ) + self.coordindex = coordindex + self.normalindex = normalindex + + @apply + def coordindex(): + def fget( self ): + return self._coordindex + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument coordindex is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,LIST(3,3,'INTEGER', scope = schema_scope))): + self._coordindex = LIST(value) + else: + self._coordindex = value + return property(**locals()) + + @apply + def normalindex(): + def fget( self ): + return self._normalindex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,LIST(3,3,'INTEGER', scope = schema_scope))): + self._normalindex = LIST(value) + else: + self._normalindex = value + else: + self._normalindex = value + return property(**locals()) + + @apply + def numberoftriangles(): + def fget( self ): + attribute_eval = SIZEOF(self.coordindex) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument numberoftriangles is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcworktime # +#################### +class ifcworktime(ifcschedulingtime): + '''Entity ifcworktime definition. + + :param recurrencepattern + :type recurrencepattern:ifcrecurrencepattern + + :param start + :type start:ifcdate + + :param finish + :type finish:ifcdate + ''' + def __init__( self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , recurrencepattern,start,finish, ): + ifcschedulingtime.__init__(self , inherited0__name , inherited1__dataorigin , inherited2__userdefineddataorigin , ) + self.recurrencepattern = recurrencepattern + self.start = start + self.finish = finish + + @apply + def recurrencepattern(): + def fget( self ): + return self._recurrencepattern + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrecurrencepattern): + self._recurrencepattern = ifcrecurrencepattern(value) + else: + self._recurrencepattern = value + else: + self._recurrencepattern = value + return property(**locals()) + + @apply + def start(): + def fget( self ): + return self._start + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdate): + self._start = ifcdate(value) + else: + self._start = value + else: + self._start = value + return property(**locals()) + + @apply + def finish(): + def fget( self ): + return self._finish + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdate): + self._finish = ifcdate(value) + else: + self._finish = value + else: + self._finish = value + return property(**locals()) + +#################### + # ENTITY ifcfiltertype # +#################### +class ifcfiltertype(ifcflowtreatmentdevicetype): + '''Entity ifcfiltertype definition. + + :param predefinedtype + :type predefinedtype:ifcfiltertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowtreatmentdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcfiltertypeenum): + self._predefinedtype = ifcfiltertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcfiltertypeenum.self.userdefined) or ((self.predefinedtype == ifcfiltertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcsolardevice # +#################### +class ifcsolardevice(ifcenergyconversiondevice): + '''Entity ifcsolardevice definition. + + :param predefinedtype + :type predefinedtype:ifcsolardevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsolardevicetypeenum): + self._predefinedtype = ifcsolardevicetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcsolardevicetypeenum.self.userdefined)) or ((self.predefinedtype == ifcsolardevicetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSOLARDEVICETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcspace # +#################### +class ifcspace(ifcspatialstructureelement): + '''Entity ifcspace definition. + + :param predefinedtype + :type predefinedtype:ifcspacetypeenum + + :param elevationwithflooring + :type elevationwithflooring:ifclengthmeasure + + :param hascoverings + :type hascoverings:SET(0,None,'ifcrelcoversspaces', scope = schema_scope) + + :param boundedby + :type boundedby:SET(0,None,'ifcrelspaceboundary', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , predefinedtype,elevationwithflooring, ): + ifcspatialstructureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , ) + self.predefinedtype = predefinedtype + self.elevationwithflooring = elevationwithflooring + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcspacetypeenum): + self._predefinedtype = ifcspacetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def elevationwithflooring(): + def fget( self ): + return self._elevationwithflooring + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._elevationwithflooring = ifclengthmeasure(value) + else: + self._elevationwithflooring = value + else: + self._elevationwithflooring = value + return property(**locals()) + + @apply + def hascoverings(): + def fget( self ): + return self._hascoverings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hascoverings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def boundedby(): + def fget( self ): + return self._boundedby + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument boundedby is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcspacetypeenum.self.userdefined)) or ((self.predefinedtype == ifcspacetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSPACETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcpolyloop # +#################### +class ifcpolyloop(ifcloop): + '''Entity ifcpolyloop definition. + + :param polygon + :type polygon:LIST(3,None,'ifccartesianpoint', scope = schema_scope) + ''' + def __init__( self , polygon, ): + ifcloop.__init__(self , ) + self.polygon = polygon + + @apply + def polygon(): + def fget( self ): + return self._polygon + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument polygon is mantatory and can not be set to None') + if not check_type(value,LIST(3,None,'ifccartesianpoint', scope = schema_scope)): + self._polygon = LIST(value) + else: + self._polygon = value + return property(**locals()) + def allpointssamedim(self): + eval_allpointssamedim_wr = (SIZEOF(None) == 0) + if not eval_allpointssamedim_wr: + raise AssertionError('Rule allpointssamedim violated') + else: + return eval_allpointssamedim_wr + + +#################### + # ENTITY ifcrelassociatesmaterial # +#################### +class ifcrelassociatesmaterial(ifcrelassociates): + '''Entity ifcrelassociatesmaterial definition. + + :param relatingmaterial + :type relatingmaterial:ifcmaterialselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingmaterial, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingmaterial = relatingmaterial + + @apply + def relatingmaterial(): + def fget( self ): + return self._relatingmaterial + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingmaterial is mantatory and can not be set to None') + if not check_type(value,ifcmaterialselect): + self._relatingmaterial = ifcmaterialselect(value) + else: + self._relatingmaterial = value + return property(**locals()) + def novoidelement(self): + eval_novoidelement_wr = (SIZEOF(None) == 0) + if not eval_novoidelement_wr: + raise AssertionError('Rule novoidelement violated') + else: + return eval_novoidelement_wr + + def allowedelements(self): + eval_allowedelements_wr = (SIZEOF(None) == 0) + if not eval_allowedelements_wr: + raise AssertionError('Rule allowedelements violated') + else: + return eval_allowedelements_wr + + +#################### + # ENTITY ifcmedicaldevicetype # +#################### +class ifcmedicaldevicetype(ifcflowterminaltype): + '''Entity ifcmedicaldevicetype definition. + + :param predefinedtype + :type predefinedtype:ifcmedicaldevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowterminaltype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcmedicaldevicetypeenum): + self._predefinedtype = ifcmedicaldevicetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcmedicaldevicetypeenum.self.userdefined) or ((self.predefinedtype == ifcmedicaldevicetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcramptype # +#################### +class ifcramptype(ifcbuildingelementtype): + '''Entity ifcramptype definition. + + :param predefinedtype + :type predefinedtype:ifcramptypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcramptypeenum): + self._predefinedtype = ifcramptypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcramptypeenum.self.userdefined) or ((self.predefinedtype == ifcramptypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccshapeprofiledef # +#################### +class ifccshapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifccshapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param width + :type width:ifcpositivelengthmeasure + + :param wallthickness + :type wallthickness:ifcpositivelengthmeasure + + :param girth + :type girth:ifcpositivelengthmeasure + + :param internalfilletradius + :type internalfilletradius:ifcnonnegativelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,width,wallthickness,girth,internalfilletradius, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.width = width + self.wallthickness = wallthickness + self.girth = girth + self.internalfilletradius = internalfilletradius + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def width(): + def fget( self ): + return self._width + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument width is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._width = ifcpositivelengthmeasure(value) + else: + self._width = value + return property(**locals()) + + @apply + def wallthickness(): + def fget( self ): + return self._wallthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument wallthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._wallthickness = ifcpositivelengthmeasure(value) + else: + self._wallthickness = value + return property(**locals()) + + @apply + def girth(): + def fget( self ): + return self._girth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument girth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._girth = ifcpositivelengthmeasure(value) + else: + self._girth = value + return property(**locals()) + + @apply + def internalfilletradius(): + def fget( self ): + return self._internalfilletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._internalfilletradius = ifcnonnegativelengthmeasure(value) + else: + self._internalfilletradius = value + else: + self._internalfilletradius = value + return property(**locals()) + def validgirth(self): + eval_validgirth_wr = (self.girth < (self.depth / 2)) + if not eval_validgirth_wr: + raise AssertionError('Rule validgirth violated') + else: + return eval_validgirth_wr + + def validinternalfilletradius(self): + eval_validinternalfilletradius_wr = (( not EXISTS(self.internalfilletradius)) or ((self.internalfilletradius <= ((self.width / 2) - self.wallthickness)) and (self.internalfilletradius <= ((self.depth / 2) - self.wallthickness)))) + if not eval_validinternalfilletradius_wr: + raise AssertionError('Rule validinternalfilletradius violated') + else: + return eval_validinternalfilletradius_wr + + def validwallthickness(self): + eval_validwallthickness_wr = ((self.wallthickness < (self.width / 2)) and (self.wallthickness < (self.depth / 2))) + if not eval_validwallthickness_wr: + raise AssertionError('Rule validwallthickness violated') + else: + return eval_validwallthickness_wr + + +#################### + # ENTITY ifcpropertytablevalue # +#################### +class ifcpropertytablevalue(ifcsimpleproperty): + '''Entity ifcpropertytablevalue definition. + + :param definingvalues + :type definingvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param definedvalues + :type definedvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + + :param expression + :type expression:ifctext + + :param definingunit + :type definingunit:ifcunit + + :param definedunit + :type definedunit:ifcunit + + :param curveinterpolation + :type curveinterpolation:ifccurveinterpolationenum + ''' + def __init__( self , inherited0__name , inherited1__description , definingvalues,definedvalues,expression,definingunit,definedunit,curveinterpolation, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.definingvalues = definingvalues + self.definedvalues = definedvalues + self.expression = expression + self.definingunit = definingunit + self.definedunit = definedunit + self.curveinterpolation = curveinterpolation + + @apply + def definingvalues(): + def fget( self ): + return self._definingvalues + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._definingvalues = LIST(value) + else: + self._definingvalues = value + else: + self._definingvalues = value + return property(**locals()) + + @apply + def definedvalues(): + def fget( self ): + return self._definedvalues + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._definedvalues = LIST(value) + else: + self._definedvalues = value + else: + self._definedvalues = value + return property(**locals()) + + @apply + def expression(): + def fget( self ): + return self._expression + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._expression = ifctext(value) + else: + self._expression = value + else: + self._expression = value + return property(**locals()) + + @apply + def definingunit(): + def fget( self ): + return self._definingunit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._definingunit = ifcunit(value) + else: + self._definingunit = value + else: + self._definingunit = value + return property(**locals()) + + @apply + def definedunit(): + def fget( self ): + return self._definedunit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._definedunit = ifcunit(value) + else: + self._definedunit = value + else: + self._definedunit = value + return property(**locals()) + + @apply + def curveinterpolation(): + def fget( self ): + return self._curveinterpolation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccurveinterpolationenum): + self._curveinterpolation = ifccurveinterpolationenum(value) + else: + self._curveinterpolation = value + else: + self._curveinterpolation = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ((( not EXISTS(self.definingvalues)) and ( not EXISTS(self.definedvalues))) or (SIZEOF(self.definingvalues) == SIZEOF(self.definedvalues))) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (( not EXISTS(self.definingvalues)) or (SIZEOF(None) == 0)) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + def wr23(self): + eval_wr23_wr = (( not EXISTS(self.definedvalues)) or (SIZEOF(None) == 0)) + if not eval_wr23_wr: + raise AssertionError('Rule wr23 violated') + else: + return eval_wr23_wr + + +#################### + # ENTITY ifcspatialzone # +#################### +class ifcspatialzone(ifcspatialelement): + '''Entity ifcspatialzone definition. + + :param predefinedtype + :type predefinedtype:ifcspatialzonetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , predefinedtype, ): + ifcspatialelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcspatialzonetypeenum): + self._predefinedtype = ifcspatialzonetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcspatialzonetypeenum.self.userdefined)) or ((self.predefinedtype == ifcspatialzonetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSPATIALZONETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcstructuralloadplanarforce # +#################### +class ifcstructuralloadplanarforce(ifcstructuralloadstatic): + '''Entity ifcstructuralloadplanarforce definition. + + :param planarforcex + :type planarforcex:ifcplanarforcemeasure + + :param planarforcey + :type planarforcey:ifcplanarforcemeasure + + :param planarforcez + :type planarforcez:ifcplanarforcemeasure + ''' + def __init__( self , inherited0__name , planarforcex,planarforcey,planarforcez, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.planarforcex = planarforcex + self.planarforcey = planarforcey + self.planarforcez = planarforcez + + @apply + def planarforcex(): + def fget( self ): + return self._planarforcex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplanarforcemeasure): + self._planarforcex = ifcplanarforcemeasure(value) + else: + self._planarforcex = value + else: + self._planarforcex = value + return property(**locals()) + + @apply + def planarforcey(): + def fget( self ): + return self._planarforcey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplanarforcemeasure): + self._planarforcey = ifcplanarforcemeasure(value) + else: + self._planarforcey = value + else: + self._planarforcey = value + return property(**locals()) + + @apply + def planarforcez(): + def fget( self ): + return self._planarforcez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplanarforcemeasure): + self._planarforcez = ifcplanarforcemeasure(value) + else: + self._planarforcez = value + else: + self._planarforcez = value + return property(**locals()) + +#################### + # ENTITY ifcbooleanclippingresult # +#################### +class ifcbooleanclippingresult(ifcbooleanresult): + '''Entity ifcbooleanclippingresult definition. + ''' + def __init__( self , inherited0__operator , inherited1__firstoperand , inherited2__secondoperand , ): + ifcbooleanresult.__init__(self , inherited0__operator , inherited1__firstoperand , inherited2__secondoperand , ) + def firstoperandtype(self): + eval_firstoperandtype_wr = ((('IFC4.IFCSWEPTAREASOLID' == TYPEOF(self.firstoperand)) or ('IFC4.IFCSWEPTDISCSOLID' == TYPEOF(self.firstoperand))) or ('IFC4.IFCBOOLEANCLIPPINGRESULT' == TYPEOF(self.firstoperand))) + if not eval_firstoperandtype_wr: + raise AssertionError('Rule firstoperandtype violated') + else: + return eval_firstoperandtype_wr + + def secondoperandtype(self): + eval_secondoperandtype_wr = ('IFC4.IFCHALFSPACESOLID' == TYPEOF(self.secondoperand)) + if not eval_secondoperandtype_wr: + raise AssertionError('Rule secondoperandtype violated') + else: + return eval_secondoperandtype_wr + + def operatortype(self): + eval_operatortype_wr = (self.operator == difference) + if not eval_operatortype_wr: + raise AssertionError('Rule operatortype violated') + else: + return eval_operatortype_wr + + +#################### + # ENTITY ifccivilelementtype # +#################### +class ifccivilelementtype(ifcelementtype): + '''Entity ifccivilelementtype definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + +#################### + # ENTITY ifcbuildingstorey # +#################### +class ifcbuildingstorey(ifcspatialstructureelement): + '''Entity ifcbuildingstorey definition. + + :param elevation + :type elevation:ifclengthmeasure + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , elevation, ): + ifcspatialstructureelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__longname , inherited8__compositiontype , ) + self.elevation = elevation + + @apply + def elevation(): + def fget( self ): + return self._elevation + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._elevation = ifclengthmeasure(value) + else: + self._elevation = value + else: + self._elevation = value + return property(**locals()) + +#################### + # ENTITY ifcsectionreinforcementproperties # +#################### +class ifcsectionreinforcementproperties(ifcpredefinedproperties): + '''Entity ifcsectionreinforcementproperties definition. + + :param longitudinalstartposition + :type longitudinalstartposition:ifclengthmeasure + + :param longitudinalendposition + :type longitudinalendposition:ifclengthmeasure + + :param transverseposition + :type transverseposition:ifclengthmeasure + + :param reinforcementrole + :type reinforcementrole:ifcreinforcingbarroleenum + + :param sectiondefinition + :type sectiondefinition:ifcsectionproperties + + :param crosssectionreinforcementdefinitions + :type crosssectionreinforcementdefinitions:SET(1,None,'ifcreinforcementbarproperties', scope = schema_scope) + ''' + def __init__( self , longitudinalstartposition,longitudinalendposition,transverseposition,reinforcementrole,sectiondefinition,crosssectionreinforcementdefinitions, ): + ifcpredefinedproperties.__init__(self , ) + self.longitudinalstartposition = longitudinalstartposition + self.longitudinalendposition = longitudinalendposition + self.transverseposition = transverseposition + self.reinforcementrole = reinforcementrole + self.sectiondefinition = sectiondefinition + self.crosssectionreinforcementdefinitions = crosssectionreinforcementdefinitions + + @apply + def longitudinalstartposition(): + def fget( self ): + return self._longitudinalstartposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument longitudinalstartposition is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._longitudinalstartposition = ifclengthmeasure(value) + else: + self._longitudinalstartposition = value + return property(**locals()) + + @apply + def longitudinalendposition(): + def fget( self ): + return self._longitudinalendposition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument longitudinalendposition is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._longitudinalendposition = ifclengthmeasure(value) + else: + self._longitudinalendposition = value + return property(**locals()) + + @apply + def transverseposition(): + def fget( self ): + return self._transverseposition + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._transverseposition = ifclengthmeasure(value) + else: + self._transverseposition = value + else: + self._transverseposition = value + return property(**locals()) + + @apply + def reinforcementrole(): + def fget( self ): + return self._reinforcementrole + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument reinforcementrole is mantatory and can not be set to None') + if not check_type(value,ifcreinforcingbarroleenum): + self._reinforcementrole = ifcreinforcingbarroleenum(value) + else: + self._reinforcementrole = value + return property(**locals()) + + @apply + def sectiondefinition(): + def fget( self ): + return self._sectiondefinition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sectiondefinition is mantatory and can not be set to None') + if not check_type(value,ifcsectionproperties): + self._sectiondefinition = ifcsectionproperties(value) + else: + self._sectiondefinition = value + return property(**locals()) + + @apply + def crosssectionreinforcementdefinitions(): + def fget( self ): + return self._crosssectionreinforcementdefinitions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument crosssectionreinforcementdefinitions is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcreinforcementbarproperties', scope = schema_scope)): + self._crosssectionreinforcementdefinitions = SET(value) + else: + self._crosssectionreinforcementdefinitions = value + return property(**locals()) + +#################### + # ENTITY ifcrelassignstoresource # +#################### +class ifcrelassignstoresource(ifcrelassigns): + '''Entity ifcrelassignstoresource definition. + + :param relatingresource + :type relatingresource:ifcresourceselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingresource, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingresource = relatingresource + + @apply + def relatingresource(): + def fget( self ): + return self._relatingresource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingresource is mantatory and can not be set to None') + if not check_type(value,ifcresourceselect): + self._relatingresource = ifcresourceselect(value) + else: + self._relatingresource = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcmaterialprofileset # +#################### +class ifcmaterialprofileset(ifcmaterialdefinition): + '''Entity ifcmaterialprofileset definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param materialprofiles + :type materialprofiles:LIST(1,None,'ifcmaterialprofile', scope = schema_scope) + + :param compositeprofile + :type compositeprofile:ifccompositeprofiledef + ''' + def __init__( self , name,description,materialprofiles,compositeprofile, ): + ifcmaterialdefinition.__init__(self , ) + self.name = name + self.description = description + self.materialprofiles = materialprofiles + self.compositeprofile = compositeprofile + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def materialprofiles(): + def fget( self ): + return self._materialprofiles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument materialprofiles is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcmaterialprofile', scope = schema_scope)): + self._materialprofiles = LIST(value) + else: + self._materialprofiles = value + return property(**locals()) + + @apply + def compositeprofile(): + def fget( self ): + return self._compositeprofile + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccompositeprofiledef): + self._compositeprofile = ifccompositeprofiledef(value) + else: + self._compositeprofile = value + else: + self._compositeprofile = value + return property(**locals()) + +#################### + # ENTITY ifcprocedure # +#################### +class ifcprocedure(ifcprocess): + '''Entity ifcprocedure definition. + + :param predefinedtype + :type predefinedtype:ifcproceduretypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , predefinedtype, ): + ifcprocess.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__longdescription , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcproceduretypeenum): + self._predefinedtype = ifcproceduretypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def hasname(self): + eval_hasname_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_hasname_wr: + raise AssertionError('Rule hasname violated') + else: + return eval_hasname_wr + + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcproceduretypeenum.self.userdefined)) or ((self.predefinedtype == ifcproceduretypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcactionrequest # +#################### +class ifcactionrequest(ifccontrol): + '''Entity ifcactionrequest definition. + + :param predefinedtype + :type predefinedtype:ifcactionrequesttypeenum + + :param status + :type status:ifclabel + + :param longdescription + :type longdescription:ifctext + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , predefinedtype,status,longdescription, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , ) + self.predefinedtype = predefinedtype + self.status = status + self.longdescription = longdescription + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactionrequesttypeenum): + self._predefinedtype = ifcactionrequesttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._status = ifclabel(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def longdescription(): + def fget( self ): + return self._longdescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._longdescription = ifctext(value) + else: + self._longdescription = value + else: + self._longdescription = value + return property(**locals()) + +#################### + # ENTITY ifcadvancedface # +#################### +class ifcadvancedface(ifcfacesurface): + '''Entity ifcadvancedface definition. + ''' + def __init__( self , inherited0__bounds , inherited1__facesurface , inherited2__samesense , ): + ifcfacesurface.__init__(self , inherited0__bounds , inherited1__facesurface , inherited2__samesense , ) + def applicablesurface(self): + eval_applicablesurface_wr = (SIZEOF(['IFC4.IFCELEMENTARYSURFACE','IFC4.IFCSWEPTSURFACE','IFC4.IFCBSPLINESURFACE'] * TYPEOF(self.self.ifcfacesurface.self.facesurface)) == 1) + if not eval_applicablesurface_wr: + raise AssertionError('Rule applicablesurface violated') + else: + return eval_applicablesurface_wr + + def requiresedgecurve(self): + eval_requiresedgecurve_wr = (SIZEOF(None) == 0) + if not eval_requiresedgecurve_wr: + raise AssertionError('Rule requiresedgecurve violated') + else: + return eval_requiresedgecurve_wr + + def applicableedgecurves(self): + eval_applicableedgecurves_wr = (SIZEOF(None) == 0) + if not eval_applicableedgecurves_wr: + raise AssertionError('Rule applicableedgecurves violated') + else: + return eval_applicableedgecurves_wr + + +#################### + # ENTITY ifcinventory # +#################### +class ifcinventory(ifcgroup): + '''Entity ifcinventory definition. + + :param predefinedtype + :type predefinedtype:ifcinventorytypeenum + + :param jurisdiction + :type jurisdiction:ifcactorselect + + :param responsiblepersons + :type responsiblepersons:SET(1,None,'ifcperson', scope = schema_scope) + + :param lastupdatedate + :type lastupdatedate:ifcdate + + :param currentvalue + :type currentvalue:ifccostvalue + + :param originalvalue + :type originalvalue:ifccostvalue + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , predefinedtype,jurisdiction,responsiblepersons,lastupdatedate,currentvalue,originalvalue, ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.predefinedtype = predefinedtype + self.jurisdiction = jurisdiction + self.responsiblepersons = responsiblepersons + self.lastupdatedate = lastupdatedate + self.currentvalue = currentvalue + self.originalvalue = originalvalue + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcinventorytypeenum): + self._predefinedtype = ifcinventorytypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def jurisdiction(): + def fget( self ): + return self._jurisdiction + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._jurisdiction = ifcactorselect(value) + else: + self._jurisdiction = value + else: + self._jurisdiction = value + return property(**locals()) + + @apply + def responsiblepersons(): + def fget( self ): + return self._responsiblepersons + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcperson', scope = schema_scope)): + self._responsiblepersons = SET(value) + else: + self._responsiblepersons = value + else: + self._responsiblepersons = value + return property(**locals()) + + @apply + def lastupdatedate(): + def fget( self ): + return self._lastupdatedate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdate): + self._lastupdatedate = ifcdate(value) + else: + self._lastupdatedate = value + else: + self._lastupdatedate = value + return property(**locals()) + + @apply + def currentvalue(): + def fget( self ): + return self._currentvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostvalue): + self._currentvalue = ifccostvalue(value) + else: + self._currentvalue = value + else: + self._currentvalue = value + return property(**locals()) + + @apply + def originalvalue(): + def fget( self ): + return self._originalvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostvalue): + self._originalvalue = ifccostvalue(value) + else: + self._originalvalue = value + else: + self._originalvalue = value + return property(**locals()) + +#################### + # ENTITY ifcrelconnectspathelements # +#################### +class ifcrelconnectspathelements(ifcrelconnectselements): + '''Entity ifcrelconnectspathelements definition. + + :param relatingpriorities + :type relatingpriorities:LIST(0,None,'(null)', scope = schema_scope) + + :param relatedpriorities + :type relatedpriorities:LIST(0,None,'(null)', scope = schema_scope) + + :param relatedconnectiontype + :type relatedconnectiontype:ifcconnectiontypeenum + + :param relatingconnectiontype + :type relatingconnectiontype:ifcconnectiontypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__connectiongeometry , inherited5__relatingelement , inherited6__relatedelement , relatingpriorities,relatedpriorities,relatedconnectiontype,relatingconnectiontype, ): + ifcrelconnectselements.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__connectiongeometry , inherited5__relatingelement , inherited6__relatedelement , ) + self.relatingpriorities = relatingpriorities + self.relatedpriorities = relatedpriorities + self.relatedconnectiontype = relatedconnectiontype + self.relatingconnectiontype = relatingconnectiontype + + @apply + def relatingpriorities(): + def fget( self ): + return self._relatingpriorities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingpriorities is mantatory and can not be set to None') + if not check_type(value,LIST(0,None,'(null)', scope = schema_scope)): + self._relatingpriorities = LIST(value) + else: + self._relatingpriorities = value + return property(**locals()) + + @apply + def relatedpriorities(): + def fget( self ): + return self._relatedpriorities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedpriorities is mantatory and can not be set to None') + if not check_type(value,LIST(0,None,'(null)', scope = schema_scope)): + self._relatedpriorities = LIST(value) + else: + self._relatedpriorities = value + return property(**locals()) + + @apply + def relatedconnectiontype(): + def fget( self ): + return self._relatedconnectiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedconnectiontype is mantatory and can not be set to None') + if not check_type(value,ifcconnectiontypeenum): + self._relatedconnectiontype = ifcconnectiontypeenum(value) + else: + self._relatedconnectiontype = value + return property(**locals()) + + @apply + def relatingconnectiontype(): + def fget( self ): + return self._relatingconnectiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingconnectiontype is mantatory and can not be set to None') + if not check_type(value,ifcconnectiontypeenum): + self._relatingconnectiontype = ifcconnectiontypeenum(value) + else: + self._relatingconnectiontype = value + return property(**locals()) + def normalizedrelatingpriorities(self): + eval_normalizedrelatingpriorities_wr = ((SIZEOF(self.relatingpriorities) == 0) or (SIZEOF(None) == SIZEOF(self.relatingpriorities))) + if not eval_normalizedrelatingpriorities_wr: + raise AssertionError('Rule normalizedrelatingpriorities violated') + else: + return eval_normalizedrelatingpriorities_wr + + def normalizedrelatedpriorities(self): + eval_normalizedrelatedpriorities_wr = ((SIZEOF(self.relatedpriorities) == 0) or (SIZEOF(None) == SIZEOF(self.relatedpriorities))) + if not eval_normalizedrelatedpriorities_wr: + raise AssertionError('Rule normalizedrelatedpriorities violated') + else: + return eval_normalizedrelatedpriorities_wr + + +#################### + # ENTITY ifccurtainwalltype # +#################### +class ifccurtainwalltype(ifcbuildingelementtype): + '''Entity ifccurtainwalltype definition. + + :param predefinedtype + :type predefinedtype:ifccurtainwalltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccurtainwalltypeenum): + self._predefinedtype = ifccurtainwalltypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccurtainwalltypeenum.self.userdefined) or ((self.predefinedtype == ifccurtainwalltypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcdraughtingpredefinedcurvefont # +#################### +class ifcdraughtingpredefinedcurvefont(ifcpredefinedcurvefont): + '''Entity ifcdraughtingpredefinedcurvefont definition. + ''' + def __init__( self , inherited0__name , ): + ifcpredefinedcurvefont.__init__(self , inherited0__name , ) + def predefinedcurvefontnames(self): + eval_predefinedcurvefontnames_wr = (self.self.ifcpredefineditem.self.name == ['continuous','chain','chain double dash','dashed','dotted','by layer']) + if not eval_predefinedcurvefontnames_wr: + raise AssertionError('Rule predefinedcurvefontnames violated') + else: + return eval_predefinedcurvefontnames_wr + + +#################### + # ENTITY ifcrelcoversbldgelements # +#################### +class ifcrelcoversbldgelements(ifcrelconnects): + '''Entity ifcrelcoversbldgelements definition. + + :param relatingbuildingelement + :type relatingbuildingelement:ifcelement + + :param relatedcoverings + :type relatedcoverings:SET(1,None,'ifccovering', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingbuildingelement,relatedcoverings, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingbuildingelement = relatingbuildingelement + self.relatedcoverings = relatedcoverings + + @apply + def relatingbuildingelement(): + def fget( self ): + return self._relatingbuildingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingbuildingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingbuildingelement = ifcelement(value) + else: + self._relatingbuildingelement = value + return property(**locals()) + + @apply + def relatedcoverings(): + def fget( self ): + return self._relatedcoverings + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedcoverings is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifccovering', scope = schema_scope)): + self._relatedcoverings = SET(value) + else: + self._relatedcoverings = value + return property(**locals()) + +#################### + # ENTITY ifcdoorstyle # +#################### +class ifcdoorstyle(ifctypeproduct): + '''Entity ifcdoorstyle definition. + + :param operationtype + :type operationtype:ifcdoorstyleoperationenum + + :param constructiontype + :type constructiontype:ifcdoorstyleconstructionenum + + :param parametertakesprecedence + :type parametertakesprecedence:BOOLEAN + + :param sizeable + :type sizeable:BOOLEAN + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , operationtype,constructiontype,parametertakesprecedence,sizeable, ): + ifctypeproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , ) + self.operationtype = operationtype + self.constructiontype = constructiontype + self.parametertakesprecedence = parametertakesprecedence + self.sizeable = sizeable + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operationtype is mantatory and can not be set to None') + if not check_type(value,ifcdoorstyleoperationenum): + self._operationtype = ifcdoorstyleoperationenum(value) + else: + self._operationtype = value + return property(**locals()) + + @apply + def constructiontype(): + def fget( self ): + return self._constructiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constructiontype is mantatory and can not be set to None') + if not check_type(value,ifcdoorstyleconstructionenum): + self._constructiontype = ifcdoorstyleconstructionenum(value) + else: + self._constructiontype = value + return property(**locals()) + + @apply + def parametertakesprecedence(): + def fget( self ): + return self._parametertakesprecedence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parametertakesprecedence is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._parametertakesprecedence = BOOLEAN(value) + else: + self._parametertakesprecedence = value + return property(**locals()) + + @apply + def sizeable(): + def fget( self ): + return self._sizeable + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sizeable is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._sizeable = BOOLEAN(value) + else: + self._sizeable = value + return property(**locals()) + +#################### + # ENTITY ifcellipse # +#################### +class ifcellipse(ifcconic): + '''Entity ifcellipse definition. + + :param semiaxis1 + :type semiaxis1:ifcpositivelengthmeasure + + :param semiaxis2 + :type semiaxis2:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , semiaxis1,semiaxis2, ): + ifcconic.__init__(self , inherited0__position , ) + self.semiaxis1 = semiaxis1 + self.semiaxis2 = semiaxis2 + + @apply + def semiaxis1(): + def fget( self ): + return self._semiaxis1 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semiaxis1 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._semiaxis1 = ifcpositivelengthmeasure(value) + else: + self._semiaxis1 = value + return property(**locals()) + + @apply + def semiaxis2(): + def fget( self ): + return self._semiaxis2 + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument semiaxis2 is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._semiaxis2 = ifcpositivelengthmeasure(value) + else: + self._semiaxis2 = value + return property(**locals()) + +#################### + # ENTITY ifcstairflighttype # +#################### +class ifcstairflighttype(ifcbuildingelementtype): + '''Entity ifcstairflighttype definition. + + :param predefinedtype + :type predefinedtype:ifcstairflighttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcstairflighttypeenum): + self._predefinedtype = ifcstairflighttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcstairflighttypeenum.self.userdefined) or ((self.predefinedtype == ifcstairflighttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcstructuralloadtemperature # +#################### +class ifcstructuralloadtemperature(ifcstructuralloadstatic): + '''Entity ifcstructuralloadtemperature definition. + + :param deltatconstant + :type deltatconstant:ifcthermodynamictemperaturemeasure + + :param deltaty + :type deltaty:ifcthermodynamictemperaturemeasure + + :param deltatz + :type deltatz:ifcthermodynamictemperaturemeasure + ''' + def __init__( self , inherited0__name , deltatconstant,deltaty,deltatz, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.deltatconstant = deltatconstant + self.deltaty = deltaty + self.deltatz = deltatz + + @apply + def deltatconstant(): + def fget( self ): + return self._deltatconstant + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._deltatconstant = ifcthermodynamictemperaturemeasure(value) + else: + self._deltatconstant = value + else: + self._deltatconstant = value + return property(**locals()) + + @apply + def deltaty(): + def fget( self ): + return self._deltaty + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._deltaty = ifcthermodynamictemperaturemeasure(value) + else: + self._deltaty = value + else: + self._deltaty = value + return property(**locals()) + + @apply + def deltatz(): + def fget( self ): + return self._deltatz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._deltatz = ifcthermodynamictemperaturemeasure(value) + else: + self._deltatz = value + else: + self._deltatz = value + return property(**locals()) + +#################### + # ENTITY ifcstyleditem # +#################### +class ifcstyleditem(ifcrepresentationitem): + '''Entity ifcstyleditem definition. + + :param item + :type item:ifcrepresentationitem + + :param styles + :type styles:SET(1,None,'ifcstyleassignmentselect', scope = schema_scope) + + :param name + :type name:ifclabel + ''' + def __init__( self , item,styles,name, ): + ifcrepresentationitem.__init__(self , ) + self.item = item + self.styles = styles + self.name = name + + @apply + def item(): + def fget( self ): + return self._item + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcrepresentationitem): + self._item = ifcrepresentationitem(value) + else: + self._item = value + else: + self._item = value + return property(**locals()) + + @apply + def styles(): + def fget( self ): + return self._styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcstyleassignmentselect', scope = schema_scope)): + self._styles = SET(value) + else: + self._styles = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + def applicableitem(self): + eval_applicableitem_wr = ( not ('IFC4.IFCSTYLEDITEM' == TYPEOF(self.item))) + if not eval_applicableitem_wr: + raise AssertionError('Rule applicableitem violated') + else: + return eval_applicableitem_wr + + +#################### + # ENTITY ifclshapeprofiledef # +#################### +class ifclshapeprofiledef(ifcparameterizedprofiledef): + '''Entity ifclshapeprofiledef definition. + + :param depth + :type depth:ifcpositivelengthmeasure + + :param width + :type width:ifcpositivelengthmeasure + + :param thickness + :type thickness:ifcpositivelengthmeasure + + :param filletradius + :type filletradius:ifcnonnegativelengthmeasure + + :param edgeradius + :type edgeradius:ifcnonnegativelengthmeasure + + :param legslope + :type legslope:ifcplaneanglemeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , depth,width,thickness,filletradius,edgeradius,legslope, ): + ifcparameterizedprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , ) + self.depth = depth + self.width = width + self.thickness = thickness + self.filletradius = filletradius + self.edgeradius = edgeradius + self.legslope = legslope + + @apply + def depth(): + def fget( self ): + return self._depth + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument depth is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._depth = ifcpositivelengthmeasure(value) + else: + self._depth = value + return property(**locals()) + + @apply + def width(): + def fget( self ): + return self._width + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._width = ifcpositivelengthmeasure(value) + else: + self._width = value + else: + self._width = value + return property(**locals()) + + @apply + def thickness(): + def fget( self ): + return self._thickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument thickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._thickness = ifcpositivelengthmeasure(value) + else: + self._thickness = value + return property(**locals()) + + @apply + def filletradius(): + def fget( self ): + return self._filletradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._filletradius = ifcnonnegativelengthmeasure(value) + else: + self._filletradius = value + else: + self._filletradius = value + return property(**locals()) + + @apply + def edgeradius(): + def fget( self ): + return self._edgeradius + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcnonnegativelengthmeasure): + self._edgeradius = ifcnonnegativelengthmeasure(value) + else: + self._edgeradius = value + else: + self._edgeradius = value + return property(**locals()) + + @apply + def legslope(): + def fget( self ): + return self._legslope + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcplaneanglemeasure): + self._legslope = ifcplaneanglemeasure(value) + else: + self._legslope = value + else: + self._legslope = value + return property(**locals()) + def validthickness(self): + eval_validthickness_wr = ((self.thickness < self.depth) and (( not EXISTS(self.width)) or (self.thickness < self.width))) + if not eval_validthickness_wr: + raise AssertionError('Rule validthickness violated') + else: + return eval_validthickness_wr + + +#################### + # ENTITY ifcdistributionsystem # +#################### +class ifcdistributionsystem(ifcsystem): + '''Entity ifcdistributionsystem definition. + + :param longname + :type longname:ifclabel + + :param predefinedtype + :type predefinedtype:ifcdistributionsystemenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , longname,predefinedtype, ): + ifcsystem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.longname = longname + self.predefinedtype = predefinedtype + + @apply + def longname(): + def fget( self ): + return self._longname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._longname = ifclabel(value) + else: + self._longname = value + else: + self._longname = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdistributionsystemenum): + self._predefinedtype = ifcdistributionsystemenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcdistributioncircuit # +#################### +class ifcdistributioncircuit(ifcdistributionsystem): + '''Entity ifcdistributioncircuit definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__longname , inherited6__predefinedtype , ): + ifcdistributionsystem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__longname , inherited6__predefinedtype , ) + +#################### + # ENTITY ifcflowinstrumenttype # +#################### +class ifcflowinstrumenttype(ifcdistributioncontrolelementtype): + '''Entity ifcflowinstrumenttype definition. + + :param predefinedtype + :type predefinedtype:ifcflowinstrumenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcflowinstrumenttypeenum): + self._predefinedtype = ifcflowinstrumenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcflowinstrumenttypeenum.self.userdefined) or ((self.predefinedtype == ifcflowinstrumenttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifccircle # +#################### +class ifccircle(ifcconic): + '''Entity ifccircle definition. + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , radius, ): + ifcconic.__init__(self , inherited0__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifcdistributionchamberelement # +#################### +class ifcdistributionchamberelement(ifcdistributionflowelement): + '''Entity ifcdistributionchamberelement definition. + + :param predefinedtype + :type predefinedtype:ifcdistributionchamberelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcdistributionflowelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdistributionchamberelementtypeenum): + self._predefinedtype = ifcdistributionchamberelementtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcdistributionchamberelementtypeenum.self.userdefined)) or ((self.predefinedtype == ifcdistributionchamberelementtypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCDISTRIBUTIONCHAMBERELEMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcmotorconnectiontype # +#################### +class ifcmotorconnectiontype(ifcenergyconversiondevicetype): + '''Entity ifcmotorconnectiontype definition. + + :param predefinedtype + :type predefinedtype:ifcmotorconnectiontypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcmotorconnectiontypeenum): + self._predefinedtype = ifcmotorconnectiontypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcmotorconnectiontypeenum.self.userdefined) or ((self.predefinedtype == ifcmotorconnectiontypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpropertysettemplate # +#################### +class ifcpropertysettemplate(ifcpropertytemplatedefinition): + '''Entity ifcpropertysettemplate definition. + + :param templatetype + :type templatetype:ifcpropertysettemplatetypeenum + + :param applicableentity + :type applicableentity:ifcidentifier + + :param haspropertytemplates + :type haspropertytemplates:SET(1,None,'ifcpropertytemplate', scope = schema_scope) + + :param defines + :type defines:SET(0,None,'ifcreldefinesbytemplate', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , templatetype,applicableentity,haspropertytemplates, ): + ifcpropertytemplatedefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.templatetype = templatetype + self.applicableentity = applicableentity + self.haspropertytemplates = haspropertytemplates + + @apply + def templatetype(): + def fget( self ): + return self._templatetype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpropertysettemplatetypeenum): + self._templatetype = ifcpropertysettemplatetypeenum(value) + else: + self._templatetype = value + else: + self._templatetype = value + return property(**locals()) + + @apply + def applicableentity(): + def fget( self ): + return self._applicableentity + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._applicableentity = ifcidentifier(value) + else: + self._applicableentity = value + else: + self._applicableentity = value + return property(**locals()) + + @apply + def haspropertytemplates(): + def fget( self ): + return self._haspropertytemplates + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument haspropertytemplates is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcpropertytemplate', scope = schema_scope)): + self._haspropertytemplates = SET(value) + else: + self._haspropertytemplates = value + return property(**locals()) + + @apply + def defines(): + def fget( self ): + return self._defines + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument defines is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def existsname(self): + eval_existsname_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_existsname_wr: + raise AssertionError('Rule existsname violated') + else: + return eval_existsname_wr + + def uniquepropertynames(self): + eval_uniquepropertynames_wr = ifcuniquepropertytemplatenames(self.haspropertytemplates) + if not eval_uniquepropertynames_wr: + raise AssertionError('Rule uniquepropertynames violated') + else: + return eval_uniquepropertynames_wr + + +#################### + # ENTITY ifcshellbasedsurfacemodel # +#################### +class ifcshellbasedsurfacemodel(ifcgeometricrepresentationitem): + '''Entity ifcshellbasedsurfacemodel definition. + + :param sbsmboundary + :type sbsmboundary:SET(1,None,'ifcshell', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , sbsmboundary, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.sbsmboundary = sbsmboundary + + @apply + def sbsmboundary(): + def fget( self ): + return self._sbsmboundary + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sbsmboundary is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcshell', scope = schema_scope)): + self._sbsmboundary = SET(value) + else: + self._sbsmboundary = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = 3 + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcprojectorder # +#################### +class ifcprojectorder(ifccontrol): + '''Entity ifcprojectorder definition. + + :param predefinedtype + :type predefinedtype:ifcprojectordertypeenum + + :param status + :type status:ifclabel + + :param longdescription + :type longdescription:ifctext + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , predefinedtype,status,longdescription, ): + ifccontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , ) + self.predefinedtype = predefinedtype + self.status = status + self.longdescription = longdescription + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcprojectordertypeenum): + self._predefinedtype = ifcprojectordertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def status(): + def fget( self ): + return self._status + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._status = ifclabel(value) + else: + self._status = value + else: + self._status = value + return property(**locals()) + + @apply + def longdescription(): + def fget( self ): + return self._longdescription + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._longdescription = ifctext(value) + else: + self._longdescription = value + else: + self._longdescription = value + return property(**locals()) + +#################### + # ENTITY ifcrampflighttype # +#################### +class ifcrampflighttype(ifcbuildingelementtype): + '''Entity ifcrampflighttype definition. + + :param predefinedtype + :type predefinedtype:ifcrampflighttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcrampflighttypeenum): + self._predefinedtype = ifcrampflighttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcrampflighttypeenum.self.userdefined) or ((self.predefinedtype == ifcrampflighttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcsurfacecurvesweptareasolid # +#################### +class ifcsurfacecurvesweptareasolid(ifcsweptareasolid): + '''Entity ifcsurfacecurvesweptareasolid definition. + + :param directrix + :type directrix:ifccurve + + :param startparam + :type startparam:ifcparametervalue + + :param endparam + :type endparam:ifcparametervalue + + :param referencesurface + :type referencesurface:ifcsurface + ''' + def __init__( self , inherited0__sweptarea , inherited1__position , directrix,startparam,endparam,referencesurface, ): + ifcsweptareasolid.__init__(self , inherited0__sweptarea , inherited1__position , ) + self.directrix = directrix + self.startparam = startparam + self.endparam = endparam + self.referencesurface = referencesurface + + @apply + def directrix(): + def fget( self ): + return self._directrix + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directrix is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._directrix = ifccurve(value) + else: + self._directrix = value + return property(**locals()) + + @apply + def startparam(): + def fget( self ): + return self._startparam + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcparametervalue): + self._startparam = ifcparametervalue(value) + else: + self._startparam = value + else: + self._startparam = value + return property(**locals()) + + @apply + def endparam(): + def fget( self ): + return self._endparam + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcparametervalue): + self._endparam = ifcparametervalue(value) + else: + self._endparam = value + else: + self._endparam = value + return property(**locals()) + + @apply + def referencesurface(): + def fget( self ): + return self._referencesurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument referencesurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._referencesurface = ifcsurface(value) + else: + self._referencesurface = value + return property(**locals()) + def directrixbounded(self): + eval_directrixbounded_wr = ((EXISTS(self.startparam) and EXISTS(self.endparam)) or (SIZEOF(['IFC4.IFCCONIC','IFC4.IFCBOUNDEDCURVE'] * TYPEOF(self.directrix)) == 1)) + if not eval_directrixbounded_wr: + raise AssertionError('Rule directrixbounded violated') + else: + return eval_directrixbounded_wr + + +#################### + # ENTITY ifcbsplinesurfacewithknots # +#################### +class ifcbsplinesurfacewithknots(ifcbsplinesurface): + '''Entity ifcbsplinesurfacewithknots definition. + + :param umultiplicities + :type umultiplicities:LIST(2,None,'INTEGER', scope = schema_scope) + + :param vmultiplicities + :type vmultiplicities:LIST(2,None,'INTEGER', scope = schema_scope) + + :param uknots + :type uknots:LIST(2,None,'REAL', scope = schema_scope) + + :param vknots + :type vknots:LIST(2,None,'REAL', scope = schema_scope) + + :param knotspec + :type knotspec:ifcknottype + + :param knotvupper + :type knotvupper:INTEGER + + :param knotuupper + :type knotuupper:INTEGER + ''' + def __init__( self , inherited0__udegree , inherited1__vdegree , inherited2__controlpointslist , inherited3__surfaceform , inherited4__uclosed , inherited5__vclosed , inherited6__selfintersect , umultiplicities,vmultiplicities,uknots,vknots,knotspec, ): + ifcbsplinesurface.__init__(self , inherited0__udegree , inherited1__vdegree , inherited2__controlpointslist , inherited3__surfaceform , inherited4__uclosed , inherited5__vclosed , inherited6__selfintersect , ) + self.umultiplicities = umultiplicities + self.vmultiplicities = vmultiplicities + self.uknots = uknots + self.vknots = vknots + self.knotspec = knotspec + + @apply + def umultiplicities(): + def fget( self ): + return self._umultiplicities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument umultiplicities is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'INTEGER', scope = schema_scope)): + self._umultiplicities = LIST(value) + else: + self._umultiplicities = value + return property(**locals()) + + @apply + def vmultiplicities(): + def fget( self ): + return self._vmultiplicities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vmultiplicities is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'INTEGER', scope = schema_scope)): + self._vmultiplicities = LIST(value) + else: + self._vmultiplicities = value + return property(**locals()) + + @apply + def uknots(): + def fget( self ): + return self._uknots + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument uknots is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._uknots = LIST(value) + else: + self._uknots = value + return property(**locals()) + + @apply + def vknots(): + def fget( self ): + return self._vknots + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vknots is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,'REAL', scope = schema_scope)): + self._vknots = LIST(value) + else: + self._vknots = value + return property(**locals()) + + @apply + def knotspec(): + def fget( self ): + return self._knotspec + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument knotspec is mantatory and can not be set to None') + if not check_type(value,ifcknottype): + self._knotspec = ifcknottype(value) + else: + self._knotspec = value + return property(**locals()) + + @apply + def knotvupper(): + def fget( self ): + attribute_eval = SIZEOF(self.vknots) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument knotvupper is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def knotuupper(): + def fget( self ): + attribute_eval = SIZEOF(self.uknots) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument knotuupper is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def udirectionconstraints(self): + eval_udirectionconstraints_wr = ifcconstraintsparambspline(self.self.ifcbsplinesurface.self.udegree,self.knotuupper,self.self.ifcbsplinesurface.self.uupper,self.umultiplicities,self.uknots) + if not eval_udirectionconstraints_wr: + raise AssertionError('Rule udirectionconstraints violated') + else: + return eval_udirectionconstraints_wr + + def vdirectionconstraints(self): + eval_vdirectionconstraints_wr = ifcconstraintsparambspline(self.self.ifcbsplinesurface.self.vdegree,self.knotvupper,self.self.ifcbsplinesurface.self.vupper,self.vmultiplicities,self.vknots) + if not eval_vdirectionconstraints_wr: + raise AssertionError('Rule vdirectionconstraints violated') + else: + return eval_vdirectionconstraints_wr + + def correspondingulists(self): + eval_correspondingulists_wr = (SIZEOF(self.umultiplicities) == self.knotuupper) + if not eval_correspondingulists_wr: + raise AssertionError('Rule correspondingulists violated') + else: + return eval_correspondingulists_wr + + def correspondingvlists(self): + eval_correspondingvlists_wr = (SIZEOF(self.vmultiplicities) == self.knotvupper) + if not eval_correspondingvlists_wr: + raise AssertionError('Rule correspondingvlists violated') + else: + return eval_correspondingvlists_wr + + +#################### + # ENTITY ifcrationalbsplinesurfacewithknots # +#################### +class ifcrationalbsplinesurfacewithknots(ifcbsplinesurfacewithknots): + '''Entity ifcrationalbsplinesurfacewithknots definition. + + :param weightsdata + :type weightsdata:LIST(2,None,LIST(2,None,'REAL', scope = schema_scope)) + + :param weights + :type weights:ARRAY(0,uupper,ARRAY(0,vupper,'REAL', scope = schema_scope)) + ''' + def __init__( self , inherited0__udegree , inherited1__vdegree , inherited2__controlpointslist , inherited3__surfaceform , inherited4__uclosed , inherited5__vclosed , inherited6__selfintersect , inherited7__umultiplicities , inherited8__vmultiplicities , inherited9__uknots , inherited10__vknots , inherited11__knotspec , weightsdata, ): + ifcbsplinesurfacewithknots.__init__(self , inherited0__udegree , inherited1__vdegree , inherited2__controlpointslist , inherited3__surfaceform , inherited4__uclosed , inherited5__vclosed , inherited6__selfintersect , inherited7__umultiplicities , inherited8__vmultiplicities , inherited9__uknots , inherited10__vknots , inherited11__knotspec , ) + self.weightsdata = weightsdata + + @apply + def weightsdata(): + def fget( self ): + return self._weightsdata + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument weightsdata is mantatory and can not be set to None') + if not check_type(value,LIST(2,None,LIST(2,None,'REAL', scope = schema_scope))): + self._weightsdata = LIST(value) + else: + self._weightsdata = value + return property(**locals()) + + @apply + def weights(): + def fget( self ): + attribute_eval = ifcmakearrayofarray(self.weightsdata,0,self.uupper,0,self.vupper) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument weights is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def correspondingweightsdatalists(self): + eval_correspondingweightsdatalists_wr = ((SIZEOF(self.weightsdata) == SIZEOF(self.self.ifcbsplinesurface.self.controlpointslist)) and (SIZEOF(self.weightsdata[1]) == SIZEOF(self.self.ifcbsplinesurface.self.controlpointslist[1]))) + if not eval_correspondingweightsdatalists_wr: + raise AssertionError('Rule correspondingweightsdatalists violated') + else: + return eval_correspondingweightsdatalists_wr + + def weightvaluesgreaterzero(self): + eval_weightvaluesgreaterzero_wr = ifcsurfaceweightspositive(self) + if not eval_weightvaluesgreaterzero_wr: + raise AssertionError('Rule weightvaluesgreaterzero violated') + else: + return eval_weightvaluesgreaterzero_wr + + +#################### + # ENTITY ifcreference # +#################### +class ifcreference(BaseEntityClass): + '''Entity ifcreference definition. + + :param typeidentifier + :type typeidentifier:ifcidentifier + + :param attributeidentifier + :type attributeidentifier:ifcidentifier + + :param instancename + :type instancename:ifclabel + + :param listpositions + :type listpositions:LIST(1,None,'INTEGER', scope = schema_scope) + + :param innerreference + :type innerreference:ifcreference + ''' + def __init__( self , typeidentifier,attributeidentifier,instancename,listpositions,innerreference, ): + self.typeidentifier = typeidentifier + self.attributeidentifier = attributeidentifier + self.instancename = instancename + self.listpositions = listpositions + self.innerreference = innerreference + + @apply + def typeidentifier(): + def fget( self ): + return self._typeidentifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._typeidentifier = ifcidentifier(value) + else: + self._typeidentifier = value + else: + self._typeidentifier = value + return property(**locals()) + + @apply + def attributeidentifier(): + def fget( self ): + return self._attributeidentifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._attributeidentifier = ifcidentifier(value) + else: + self._attributeidentifier = value + else: + self._attributeidentifier = value + return property(**locals()) + + @apply + def instancename(): + def fget( self ): + return self._instancename + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._instancename = ifclabel(value) + else: + self._instancename = value + else: + self._instancename = value + return property(**locals()) + + @apply + def listpositions(): + def fget( self ): + return self._listpositions + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'INTEGER', scope = schema_scope)): + self._listpositions = LIST(value) + else: + self._listpositions = value + else: + self._listpositions = value + return property(**locals()) + + @apply + def innerreference(): + def fget( self ): + return self._innerreference + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreference): + self._innerreference = ifcreference(value) + else: + self._innerreference = value + else: + self._innerreference = value + return property(**locals()) + +#################### + # ENTITY ifcspatialzonetype # +#################### +class ifcspatialzonetype(ifcspatialelementtype): + '''Entity ifcspatialzonetype definition. + + :param predefinedtype + :type predefinedtype:ifcspatialzonetypeenum + + :param longname + :type longname:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype,longname, ): + ifcspatialelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + self.longname = longname + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcspatialzonetypeenum): + self._predefinedtype = ifcspatialzonetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def longname(): + def fget( self ): + return self._longname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._longname = ifclabel(value) + else: + self._longname = value + else: + self._longname = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcspatialzonetypeenum.self.userdefined) or ((self.predefinedtype == ifcspatialzonetypeenum.self.userdefined) and EXISTS(self.self.ifcspatialelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcstructuralpointaction # +#################### +class ifcstructuralpointaction(ifcstructuralaction): + '''Entity ifcstructuralpointaction definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , ): + ifcstructuralaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , ) + def suitableloadtype(self): + eval_suitableloadtype_wr = (SIZEOF(['IFC4.IFCSTRUCTURALLOADSINGLEFORCE','IFC4.IFCSTRUCTURALLOADSINGLEDISPLACEMENT'] * TYPEOF(self.self.ifcstructuralactivity.self.appliedload)) == 1) + if not eval_suitableloadtype_wr: + raise AssertionError('Rule suitableloadtype violated') + else: + return eval_suitableloadtype_wr + + +#################### + # ENTITY ifcpropertyreferencevalue # +#################### +class ifcpropertyreferencevalue(ifcsimpleproperty): + '''Entity ifcpropertyreferencevalue definition. + + :param usagename + :type usagename:ifctext + + :param propertyreference + :type propertyreference:ifcobjectreferenceselect + ''' + def __init__( self , inherited0__name , inherited1__description , usagename,propertyreference, ): + ifcsimpleproperty.__init__(self , inherited0__name , inherited1__description , ) + self.usagename = usagename + self.propertyreference = propertyreference + + @apply + def usagename(): + def fget( self ): + return self._usagename + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._usagename = ifctext(value) + else: + self._usagename = value + else: + self._usagename = value + return property(**locals()) + + @apply + def propertyreference(): + def fget( self ): + return self._propertyreference + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcobjectreferenceselect): + self._propertyreference = ifcobjectreferenceselect(value) + else: + self._propertyreference = value + else: + self._propertyreference = value + return property(**locals()) + +#################### + # ENTITY ifcpointonsurface # +#################### +class ifcpointonsurface(ifcpoint): + '''Entity ifcpointonsurface definition. + + :param basissurface + :type basissurface:ifcsurface + + :param pointparameteru + :type pointparameteru:ifcparametervalue + + :param pointparameterv + :type pointparameterv:ifcparametervalue + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , basissurface,pointparameteru,pointparameterv, ): + ifcpoint.__init__(self , ) + self.basissurface = basissurface + self.pointparameteru = pointparameteru + self.pointparameterv = pointparameterv + + @apply + def basissurface(): + def fget( self ): + return self._basissurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basissurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._basissurface = ifcsurface(value) + else: + self._basissurface = value + return property(**locals()) + + @apply + def pointparameteru(): + def fget( self ): + return self._pointparameteru + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pointparameteru is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._pointparameteru = ifcparametervalue(value) + else: + self._pointparameteru = value + return property(**locals()) + + @apply + def pointparameterv(): + def fget( self ): + return self._pointparameterv + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pointparameterv is mantatory and can not be set to None') + if not check_type(value,ifcparametervalue): + self._pointparameterv = ifcparametervalue(value) + else: + self._pointparameterv = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.basissurface.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcboilertype # +#################### +class ifcboilertype(ifcenergyconversiondevicetype): + '''Entity ifcboilertype definition. + + :param predefinedtype + :type predefinedtype:ifcboilertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcboilertypeenum): + self._predefinedtype = ifcboilertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcboilertypeenum.self.userdefined) or ((self.predefinedtype == ifcboilertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcactor # +#################### +class ifcactor(ifcobject): + '''Entity ifcactor definition. + + :param theactor + :type theactor:ifcactorselect + + :param isactingupon + :type isactingupon:SET(0,None,'ifcrelassignstoactor', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , theactor, ): + ifcobject.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.theactor = theactor + + @apply + def theactor(): + def fget( self ): + return self._theactor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument theactor is mantatory and can not be set to None') + if not check_type(value,ifcactorselect): + self._theactor = ifcactorselect(value) + else: + self._theactor = value + return property(**locals()) + + @apply + def isactingupon(): + def fget( self ): + return self._isactingupon + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument isactingupon is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcoccupant # +#################### +class ifcoccupant(ifcactor): + '''Entity ifcoccupant definition. + + :param predefinedtype + :type predefinedtype:ifcoccupanttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__theactor , predefinedtype, ): + ifcactor.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__theactor , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcoccupanttypeenum): + self._predefinedtype = ifcoccupanttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (( not (self.predefinedtype == ifcoccupanttypeenum.self.userdefined)) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcrelcontainedinspatialstructure # +#################### +class ifcrelcontainedinspatialstructure(ifcrelconnects): + '''Entity ifcrelcontainedinspatialstructure definition. + + :param relatedelements + :type relatedelements:SET(1,None,'ifcproduct', scope = schema_scope) + + :param relatingstructure + :type relatingstructure:ifcspatialelement + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedelements,relatingstructure, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedelements = relatedelements + self.relatingstructure = relatingstructure + + @apply + def relatedelements(): + def fget( self ): + return self._relatedelements + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedelements is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproduct', scope = schema_scope)): + self._relatedelements = SET(value) + else: + self._relatedelements = value + return property(**locals()) + + @apply + def relatingstructure(): + def fget( self ): + return self._relatingstructure + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingstructure is mantatory and can not be set to None') + if not check_type(value,ifcspatialelement): + self._relatingstructure = ifcspatialelement(value) + else: + self._relatingstructure = value + return property(**locals()) + def wr31(self): + eval_wr31_wr = (SIZEOF(None) == 0) + if not eval_wr31_wr: + raise AssertionError('Rule wr31 violated') + else: + return eval_wr31_wr + + +#################### + # ENTITY ifcstructuralpointconnection # +#################### +class ifcstructuralpointconnection(ifcstructuralconnection): + '''Entity ifcstructuralpointconnection definition. + + :param conditioncoordinatesystem + :type conditioncoordinatesystem:ifcaxis2placement3d + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , conditioncoordinatesystem, ): + ifcstructuralconnection.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedcondition , ) + self.conditioncoordinatesystem = conditioncoordinatesystem + + @apply + def conditioncoordinatesystem(): + def fget( self ): + return self._conditioncoordinatesystem + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcaxis2placement3d): + self._conditioncoordinatesystem = ifcaxis2placement3d(value) + else: + self._conditioncoordinatesystem = value + else: + self._conditioncoordinatesystem = value + return property(**locals()) + +#################### + # ENTITY ifccomplexpropertytemplate # +#################### +class ifccomplexpropertytemplate(ifcpropertytemplate): + '''Entity ifccomplexpropertytemplate definition. + + :param usagename + :type usagename:ifclabel + + :param templatetype + :type templatetype:ifccomplexpropertytemplatetypeenum + + :param haspropertytemplates + :type haspropertytemplates:SET(1,None,'ifcpropertytemplate', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , usagename,templatetype,haspropertytemplates, ): + ifcpropertytemplate.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.usagename = usagename + self.templatetype = templatetype + self.haspropertytemplates = haspropertytemplates + + @apply + def usagename(): + def fget( self ): + return self._usagename + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._usagename = ifclabel(value) + else: + self._usagename = value + else: + self._usagename = value + return property(**locals()) + + @apply + def templatetype(): + def fget( self ): + return self._templatetype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccomplexpropertytemplatetypeenum): + self._templatetype = ifccomplexpropertytemplatetypeenum(value) + else: + self._templatetype = value + else: + self._templatetype = value + return property(**locals()) + + @apply + def haspropertytemplates(): + def fget( self ): + return self._haspropertytemplates + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'ifcpropertytemplate', scope = schema_scope)): + self._haspropertytemplates = SET(value) + else: + self._haspropertytemplates = value + else: + self._haspropertytemplates = value + return property(**locals()) + def uniquepropertynames(self): + eval_uniquepropertynames_wr = ifcuniquepropertytemplatenames(self.haspropertytemplates) + if not eval_uniquepropertynames_wr: + raise AssertionError('Rule uniquepropertynames violated') + else: + return eval_uniquepropertynames_wr + + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcoffsetcurve3d # +#################### +class ifcoffsetcurve3d(ifccurve): + '''Entity ifcoffsetcurve3d definition. + + :param basiscurve + :type basiscurve:ifccurve + + :param distance + :type distance:ifclengthmeasure + + :param selfintersect + :type selfintersect:LOGICAL + + :param refdirection + :type refdirection:ifcdirection + ''' + def __init__( self , basiscurve,distance,selfintersect,refdirection, ): + ifccurve.__init__(self , ) + self.basiscurve = basiscurve + self.distance = distance + self.selfintersect = selfintersect + self.refdirection = refdirection + + @apply + def basiscurve(): + def fget( self ): + return self._basiscurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basiscurve is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._basiscurve = ifccurve(value) + else: + self._basiscurve = value + return property(**locals()) + + @apply + def distance(): + def fget( self ): + return self._distance + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distance is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._distance = ifclengthmeasure(value) + else: + self._distance = value + return property(**locals()) + + @apply + def selfintersect(): + def fget( self ): + return self._selfintersect + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument selfintersect is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._selfintersect = LOGICAL(value) + else: + self._selfintersect = value + return property(**locals()) + + @apply + def refdirection(): + def fget( self ): + return self._refdirection + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument refdirection is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._refdirection = ifcdirection(value) + else: + self._refdirection = value + return property(**locals()) + def dimis2d(self): + eval_dimis2d_wr = (self.basiscurve.self.dim == 3) + if not eval_dimis2d_wr: + raise AssertionError('Rule dimis2d violated') + else: + return eval_dimis2d_wr + + +#################### + # ENTITY ifcvibrationisolatortype # +#################### +class ifcvibrationisolatortype(ifcelementcomponenttype): + '''Entity ifcvibrationisolatortype definition. + + :param predefinedtype + :type predefinedtype:ifcvibrationisolatortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcelementcomponenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcvibrationisolatortypeenum): + self._predefinedtype = ifcvibrationisolatortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcvibrationisolatortypeenum.self.userdefined) or ((self.predefinedtype == ifcvibrationisolatortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcconnectionvolumegeometry # +#################### +class ifcconnectionvolumegeometry(ifcconnectiongeometry): + '''Entity ifcconnectionvolumegeometry definition. + + :param volumeonrelatingelement + :type volumeonrelatingelement:ifcsolidorshell + + :param volumeonrelatedelement + :type volumeonrelatedelement:ifcsolidorshell + ''' + def __init__( self , volumeonrelatingelement,volumeonrelatedelement, ): + ifcconnectiongeometry.__init__(self , ) + self.volumeonrelatingelement = volumeonrelatingelement + self.volumeonrelatedelement = volumeonrelatedelement + + @apply + def volumeonrelatingelement(): + def fget( self ): + return self._volumeonrelatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument volumeonrelatingelement is mantatory and can not be set to None') + if not check_type(value,ifcsolidorshell): + self._volumeonrelatingelement = ifcsolidorshell(value) + else: + self._volumeonrelatingelement = value + return property(**locals()) + + @apply + def volumeonrelatedelement(): + def fget( self ): + return self._volumeonrelatedelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsolidorshell): + self._volumeonrelatedelement = ifcsolidorshell(value) + else: + self._volumeonrelatedelement = value + else: + self._volumeonrelatedelement = value + return property(**locals()) + +#################### + # ENTITY ifcelectricappliance # +#################### +class ifcelectricappliance(ifcflowterminal): + '''Entity ifcelectricappliance definition. + + :param predefinedtype + :type predefinedtype:ifcelectricappliancetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcelectricappliancetypeenum): + self._predefinedtype = ifcelectricappliancetypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcelectricappliancetypeenum.self.userdefined)) or ((self.predefinedtype == ifcelectricappliancetypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCELECTRICAPPLIANCETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcreldefinesbyobject # +#################### +class ifcreldefinesbyobject(ifcreldefines): + '''Entity ifcreldefinesbyobject definition. + + :param relatedobjects + :type relatedobjects:SET(1,None,'ifcobject', scope = schema_scope) + + :param relatingobject + :type relatingobject:ifcobject + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedobjects,relatingobject, ): + ifcreldefines.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedobjects = relatedobjects + self.relatingobject = relatingobject + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcobject', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + + @apply + def relatingobject(): + def fget( self ): + return self._relatingobject + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingobject is mantatory and can not be set to None') + if not check_type(value,ifcobject): + self._relatingobject = ifcobject(value) + else: + self._relatingobject = value + return property(**locals()) + +#################### + # ENTITY ifctablecolumn # +#################### +class ifctablecolumn(BaseEntityClass): + '''Entity ifctablecolumn definition. + + :param identifier + :type identifier:ifcidentifier + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param unit + :type unit:ifcunit + + :param referencepath + :type referencepath:ifcreference + ''' + def __init__( self , identifier,name,description,unit,referencepath, ): + self.identifier = identifier + self.name = name + self.description = description + self.unit = unit + self.referencepath = referencepath + + @apply + def identifier(): + def fget( self ): + return self._identifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identifier = ifcidentifier(value) + else: + self._identifier = value + else: + self._identifier = value + return property(**locals()) + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def unit(): + def fget( self ): + return self._unit + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcunit): + self._unit = ifcunit(value) + else: + self._unit = value + else: + self._unit = value + return property(**locals()) + + @apply + def referencepath(): + def fget( self ): + return self._referencepath + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreference): + self._referencepath = ifcreference(value) + else: + self._referencepath = value + else: + self._referencepath = value + return property(**locals()) + +#################### + # ENTITY ifctransformertype # +#################### +class ifctransformertype(ifcenergyconversiondevicetype): + '''Entity ifctransformertype definition. + + :param predefinedtype + :type predefinedtype:ifctransformertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctransformertypeenum): + self._predefinedtype = ifctransformertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifctransformertypeenum.self.userdefined) or ((self.predefinedtype == ifctransformertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcapplication # +#################### +class ifcapplication(BaseEntityClass): + '''Entity ifcapplication definition. + + :param applicationdeveloper + :type applicationdeveloper:ifcorganization + + :param version + :type version:ifclabel + + :param applicationfullname + :type applicationfullname:ifclabel + + :param applicationidentifier + :type applicationidentifier:ifcidentifier + ''' + def __init__( self , applicationdeveloper,version,applicationfullname,applicationidentifier, ): + self.applicationdeveloper = applicationdeveloper + self.version = version + self.applicationfullname = applicationfullname + self.applicationidentifier = applicationidentifier + + @apply + def applicationdeveloper(): + def fget( self ): + return self._applicationdeveloper + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applicationdeveloper is mantatory and can not be set to None') + if not check_type(value,ifcorganization): + self._applicationdeveloper = ifcorganization(value) + else: + self._applicationdeveloper = value + return property(**locals()) + + @apply + def version(): + def fget( self ): + return self._version + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument version is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._version = ifclabel(value) + else: + self._version = value + return property(**locals()) + + @apply + def applicationfullname(): + def fget( self ): + return self._applicationfullname + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applicationfullname is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._applicationfullname = ifclabel(value) + else: + self._applicationfullname = value + return property(**locals()) + + @apply + def applicationidentifier(): + def fget( self ): + return self._applicationidentifier + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument applicationidentifier is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._applicationidentifier = ifcidentifier(value) + else: + self._applicationidentifier = value + return property(**locals()) + +#################### + # ENTITY ifcreldeclares # +#################### +class ifcreldeclares(ifcrelationship): + '''Entity ifcreldeclares definition. + + :param relatingcontext + :type relatingcontext:ifccontext + + :param relateddefinitions + :type relateddefinitions:SET(1,None,'ifcdefinitionselect', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingcontext,relateddefinitions, ): + ifcrelationship.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingcontext = relatingcontext + self.relateddefinitions = relateddefinitions + + @apply + def relatingcontext(): + def fget( self ): + return self._relatingcontext + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingcontext is mantatory and can not be set to None') + if not check_type(value,ifccontext): + self._relatingcontext = ifccontext(value) + else: + self._relatingcontext = value + return property(**locals()) + + @apply + def relateddefinitions(): + def fget( self ): + return self._relateddefinitions + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relateddefinitions is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcdefinitionselect', scope = schema_scope)): + self._relateddefinitions = SET(value) + else: + self._relateddefinitions = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifccoveringtype # +#################### +class ifccoveringtype(ifcbuildingelementtype): + '''Entity ifccoveringtype definition. + + :param predefinedtype + :type predefinedtype:ifccoveringtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccoveringtypeenum): + self._predefinedtype = ifccoveringtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccoveringtypeenum.self.userdefined) or ((self.predefinedtype == ifccoveringtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcproductdefinitionshape # +#################### +class ifcproductdefinitionshape(ifcproductrepresentation): + '''Entity ifcproductdefinitionshape definition. + + :param shapeofproduct + :type shapeofproduct:SET(1,None,'ifcproduct', scope = schema_scope) + + :param hasshapeaspects + :type hasshapeaspects:SET(0,None,'ifcshapeaspect', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__representations , ): + ifcproductrepresentation.__init__(self , inherited0__name , inherited1__description , inherited2__representations , ) + + @apply + def shapeofproduct(): + def fget( self ): + return self._shapeofproduct + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument shapeofproduct is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def hasshapeaspects(): + def fget( self ): + return self._hasshapeaspects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasshapeaspects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def onlyshapemodel(self): + eval_onlyshapemodel_wr = (SIZEOF(None) == 0) + if not eval_onlyshapemodel_wr: + raise AssertionError('Rule onlyshapemodel violated') + else: + return eval_onlyshapemodel_wr + + +#################### + # ENTITY ifccirclehollowprofiledef # +#################### +class ifccirclehollowprofiledef(ifccircleprofiledef): + '''Entity ifccirclehollowprofiledef definition. + + :param wallthickness + :type wallthickness:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__radius , wallthickness, ): + ifccircleprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__position , inherited3__radius , ) + self.wallthickness = wallthickness + + @apply + def wallthickness(): + def fget( self ): + return self._wallthickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument wallthickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._wallthickness = ifcpositivelengthmeasure(value) + else: + self._wallthickness = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = (self.wallthickness < self.self.ifccircleprofiledef.self.radius) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcgeographicelementtype # +#################### +class ifcgeographicelementtype(ifcelementtype): + '''Entity ifcgeographicelementtype definition. + + :param predefinedtype + :type predefinedtype:ifcgeographicelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcgeographicelementtypeenum): + self._predefinedtype = ifcgeographicelementtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcgeographicelementtypeenum.self.userdefined) or ((self.predefinedtype == ifcgeographicelementtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcairterminal # +#################### +class ifcairterminal(ifcflowterminal): + '''Entity ifcairterminal definition. + + :param predefinedtype + :type predefinedtype:ifcairterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcairterminaltypeenum): + self._predefinedtype = ifcairterminaltypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcairterminaltypeenum.self.userdefined)) or ((self.predefinedtype == ifcairterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCAIRTERMINALTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifccenterlineprofiledef # +#################### +class ifccenterlineprofiledef(ifcarbitraryopenprofiledef): + '''Entity ifccenterlineprofiledef definition. + + :param thickness + :type thickness:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , inherited2__curve , thickness, ): + ifcarbitraryopenprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , inherited2__curve , ) + self.thickness = thickness + + @apply + def thickness(): + def fget( self ): + return self._thickness + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument thickness is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._thickness = ifcpositivelengthmeasure(value) + else: + self._thickness = value + return property(**locals()) + +#################### + # ENTITY ifcfaceouterbound # +#################### +class ifcfaceouterbound(ifcfacebound): + '''Entity ifcfaceouterbound definition. + ''' + def __init__( self , inherited0__bound , inherited1__orientation , ): + ifcfacebound.__init__(self , inherited0__bound , inherited1__orientation , ) + +#################### + # ENTITY ifcvector # +#################### +class ifcvector(ifcgeometricrepresentationitem): + '''Entity ifcvector definition. + + :param orientation + :type orientation:ifcdirection + + :param magnitude + :type magnitude:ifclengthmeasure + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , orientation,magnitude, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.orientation = orientation + self.magnitude = magnitude + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._orientation = ifcdirection(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def magnitude(): + def fget( self ): + return self._magnitude + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument magnitude is mantatory and can not be set to None') + if not check_type(value,ifclengthmeasure): + self._magnitude = ifclengthmeasure(value) + else: + self._magnitude = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = self.orientation.self.dim + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def maggreaterorequalzero(self): + eval_maggreaterorequalzero_wr = (self.magnitude >= 0) + if not eval_maggreaterorequalzero_wr: + raise AssertionError('Rule maggreaterorequalzero violated') + else: + return eval_maggreaterorequalzero_wr + + +#################### + # ENTITY ifccurtainwall # +#################### +class ifccurtainwall(ifcbuildingelement): + '''Entity ifccurtainwall definition. + + :param predefinedtype + :type predefinedtype:ifccurtainwalltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccurtainwalltypeenum): + self._predefinedtype = ifccurtainwalltypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifccurtainwalltypeenum.self.userdefined)) or ((self.predefinedtype == ifccurtainwalltypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCURTAINWALLTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcexternallydefinedhatchstyle # +#################### +class ifcexternallydefinedhatchstyle(ifcexternalreference): + '''Entity ifcexternallydefinedhatchstyle definition. + ''' + def __init__( self , inherited0__location , inherited1__identification , inherited2__name , ): + ifcexternalreference.__init__(self , inherited0__location , inherited1__identification , inherited2__name , ) + +#################### + # ENTITY ifcmeasurewithunit # +#################### +class ifcmeasurewithunit(BaseEntityClass): + '''Entity ifcmeasurewithunit definition. + + :param valuecomponent + :type valuecomponent:ifcvalue + + :param unitcomponent + :type unitcomponent:ifcunit + ''' + def __init__( self , valuecomponent,unitcomponent, ): + self.valuecomponent = valuecomponent + self.unitcomponent = unitcomponent + + @apply + def valuecomponent(): + def fget( self ): + return self._valuecomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument valuecomponent is mantatory and can not be set to None') + if not check_type(value,ifcvalue): + self._valuecomponent = ifcvalue(value) + else: + self._valuecomponent = value + return property(**locals()) + + @apply + def unitcomponent(): + def fget( self ): + return self._unitcomponent + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument unitcomponent is mantatory and can not be set to None') + if not check_type(value,ifcunit): + self._unitcomponent = ifcunit(value) + else: + self._unitcomponent = value + return property(**locals()) + +#################### + # ENTITY ifcrectangularpyramid # +#################### +class ifcrectangularpyramid(ifccsgprimitive3d): + '''Entity ifcrectangularpyramid definition. + + :param xlength + :type xlength:ifcpositivelengthmeasure + + :param ylength + :type ylength:ifcpositivelengthmeasure + + :param height + :type height:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , xlength,ylength,height, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.xlength = xlength + self.ylength = ylength + self.height = height + + @apply + def xlength(): + def fget( self ): + return self._xlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument xlength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._xlength = ifcpositivelengthmeasure(value) + else: + self._xlength = value + return property(**locals()) + + @apply + def ylength(): + def fget( self ): + return self._ylength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ylength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ylength = ifcpositivelengthmeasure(value) + else: + self._ylength = value + return property(**locals()) + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._height = ifcpositivelengthmeasure(value) + else: + self._height = value + return property(**locals()) + +#################### + # ENTITY ifcsurfacestyle # +#################### +class ifcsurfacestyle(ifcpresentationstyle): + '''Entity ifcsurfacestyle definition. + + :param side + :type side:ifcsurfaceside + + :param styles + :type styles:SET(1,5,'ifcsurfacestyleelementselect', scope = schema_scope) + ''' + def __init__( self , inherited0__name , side,styles, ): + ifcpresentationstyle.__init__(self , inherited0__name , ) + self.side = side + self.styles = styles + + @apply + def side(): + def fget( self ): + return self._side + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument side is mantatory and can not be set to None') + if not check_type(value,ifcsurfaceside): + self._side = ifcsurfaceside(value) + else: + self._side = value + return property(**locals()) + + @apply + def styles(): + def fget( self ): + return self._styles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument styles is mantatory and can not be set to None') + if not check_type(value,SET(1,5,'ifcsurfacestyleelementselect', scope = schema_scope)): + self._styles = SET(value) + else: + self._styles = value + return property(**locals()) + def maxoneshading(self): + eval_maxoneshading_wr = (SIZEOF(None) <= 1) + if not eval_maxoneshading_wr: + raise AssertionError('Rule maxoneshading violated') + else: + return eval_maxoneshading_wr + + def maxonelighting(self): + eval_maxonelighting_wr = (SIZEOF(None) <= 1) + if not eval_maxonelighting_wr: + raise AssertionError('Rule maxonelighting violated') + else: + return eval_maxonelighting_wr + + def maxonerefraction(self): + eval_maxonerefraction_wr = (SIZEOF(None) <= 1) + if not eval_maxonerefraction_wr: + raise AssertionError('Rule maxonerefraction violated') + else: + return eval_maxonerefraction_wr + + def maxonetextures(self): + eval_maxonetextures_wr = (SIZEOF(None) <= 1) + if not eval_maxonetextures_wr: + raise AssertionError('Rule maxonetextures violated') + else: + return eval_maxonetextures_wr + + def maxoneextdefined(self): + eval_maxoneextdefined_wr = (SIZEOF(None) <= 1) + if not eval_maxoneextdefined_wr: + raise AssertionError('Rule maxoneextdefined violated') + else: + return eval_maxoneextdefined_wr + + +#################### + # ENTITY ifcelectricmotortype # +#################### +class ifcelectricmotortype(ifcenergyconversiondevicetype): + '''Entity ifcelectricmotortype definition. + + :param predefinedtype + :type predefinedtype:ifcelectricmotortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelectricmotortypeenum): + self._predefinedtype = ifcelectricmotortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcelectricmotortypeenum.self.userdefined) or ((self.predefinedtype == ifcelectricmotortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcproceduretype # +#################### +class ifcproceduretype(ifctypeprocess): + '''Entity ifcproceduretype definition. + + :param predefinedtype + :type predefinedtype:ifcproceduretypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__processtype , predefinedtype, ): + ifctypeprocess.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__identification , inherited7__longdescription , inherited8__processtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcproceduretypeenum): + self._predefinedtype = ifcproceduretypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcproceduretypeenum.self.userdefined) or ((self.predefinedtype == ifcproceduretypeenum.self.userdefined) and EXISTS(self.self.ifctypeprocess.self.processtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcirregulartimeseriesvalue # +#################### +class ifcirregulartimeseriesvalue(BaseEntityClass): + '''Entity ifcirregulartimeseriesvalue definition. + + :param timestamp + :type timestamp:ifcdatetime + + :param listvalues + :type listvalues:LIST(1,None,'ifcvalue', scope = schema_scope) + ''' + def __init__( self , timestamp,listvalues, ): + self.timestamp = timestamp + self.listvalues = listvalues + + @apply + def timestamp(): + def fget( self ): + return self._timestamp + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument timestamp is mantatory and can not be set to None') + if not check_type(value,ifcdatetime): + self._timestamp = ifcdatetime(value) + else: + self._timestamp = value + return property(**locals()) + + @apply + def listvalues(): + def fget( self ): + return self._listvalues + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument listvalues is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcvalue', scope = schema_scope)): + self._listvalues = LIST(value) + else: + self._listvalues = value + return property(**locals()) + +#################### + # ENTITY ifcoutlet # +#################### +class ifcoutlet(ifcflowterminal): + '''Entity ifcoutlet definition. + + :param predefinedtype + :type predefinedtype:ifcoutlettypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcoutlettypeenum): + self._predefinedtype = ifcoutlettypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcoutlettypeenum.self.userdefined)) or ((self.predefinedtype == ifcoutlettypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCOUTLETTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcsolardevicetype # +#################### +class ifcsolardevicetype(ifcenergyconversiondevicetype): + '''Entity ifcsolardevicetype definition. + + :param predefinedtype + :type predefinedtype:ifcsolardevicetypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcsolardevicetypeenum): + self._predefinedtype = ifcsolardevicetypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcsolardevicetypeenum.self.userdefined) or ((self.predefinedtype == ifcsolardevicetypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcpresentationlayerassignment # +#################### +class ifcpresentationlayerassignment(BaseEntityClass): + '''Entity ifcpresentationlayerassignment definition. + + :param name + :type name:ifclabel + + :param description + :type description:ifctext + + :param assigneditems + :type assigneditems:SET(1,None,'ifclayereditem', scope = schema_scope) + + :param identifier + :type identifier:ifcidentifier + ''' + def __init__( self , name,description,assigneditems,identifier, ): + self.name = name + self.description = description + self.assigneditems = assigneditems + self.identifier = identifier + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def assigneditems(): + def fget( self ): + return self._assigneditems + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument assigneditems is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifclayereditem', scope = schema_scope)): + self._assigneditems = SET(value) + else: + self._assigneditems = value + return property(**locals()) + + @apply + def identifier(): + def fget( self ): + return self._identifier + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identifier = ifcidentifier(value) + else: + self._identifier = value + else: + self._identifier = value + return property(**locals()) + def applicableitems(self): + eval_applicableitems_wr = (SIZEOF(None) == SIZEOF(self.assigneditems)) + if not eval_applicableitems_wr: + raise AssertionError('Rule applicableitems violated') + else: + return eval_applicableitems_wr + + +#################### + # ENTITY ifcprojectionelement # +#################### +class ifcprojectionelement(ifcfeatureelementaddition): + '''Entity ifcprojectionelement definition. + + :param predefinedtype + :type predefinedtype:ifcprojectionelementtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcfeatureelementaddition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcprojectionelementtypeenum): + self._predefinedtype = ifcprojectionelementtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifcrelassociatesapproval # +#################### +class ifcrelassociatesapproval(ifcrelassociates): + '''Entity ifcrelassociatesapproval definition. + + :param relatingapproval + :type relatingapproval:ifcapproval + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingapproval, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingapproval = relatingapproval + + @apply + def relatingapproval(): + def fget( self ): + return self._relatingapproval + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingapproval is mantatory and can not be set to None') + if not check_type(value,ifcapproval): + self._relatingapproval = ifcapproval(value) + else: + self._relatingapproval = value + return property(**locals()) + +#################### + # ENTITY ifccurvestyle # +#################### +class ifccurvestyle(ifcpresentationstyle): + '''Entity ifccurvestyle definition. + + :param curvefont + :type curvefont:ifccurvefontorscaledcurvefontselect + + :param curvewidth + :type curvewidth:ifcsizeselect + + :param curvecolour + :type curvecolour:ifccolour + + :param modelordraughting + :type modelordraughting:BOOLEAN + ''' + def __init__( self , inherited0__name , curvefont,curvewidth,curvecolour,modelordraughting, ): + ifcpresentationstyle.__init__(self , inherited0__name , ) + self.curvefont = curvefont + self.curvewidth = curvewidth + self.curvecolour = curvecolour + self.modelordraughting = modelordraughting + + @apply + def curvefont(): + def fget( self ): + return self._curvefont + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccurvefontorscaledcurvefontselect): + self._curvefont = ifccurvefontorscaledcurvefontselect(value) + else: + self._curvefont = value + else: + self._curvefont = value + return property(**locals()) + + @apply + def curvewidth(): + def fget( self ): + return self._curvewidth + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcsizeselect): + self._curvewidth = ifcsizeselect(value) + else: + self._curvewidth = value + else: + self._curvewidth = value + return property(**locals()) + + @apply + def curvecolour(): + def fget( self ): + return self._curvecolour + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolour): + self._curvecolour = ifccolour(value) + else: + self._curvecolour = value + else: + self._curvecolour = value + return property(**locals()) + + @apply + def modelordraughting(): + def fget( self ): + return self._modelordraughting + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,BOOLEAN): + self._modelordraughting = BOOLEAN(value) + else: + self._modelordraughting = value + else: + self._modelordraughting = value + return property(**locals()) + def measureofwidth(self): + eval_measureofwidth_wr = ((( not EXISTS(self.curvewidth)) or ('IFC4.IFCPOSITIVELENGTHMEASURE' == TYPEOF(self.curvewidth))) or (('IFC4.IFCDESCRIPTIVEMEASURE' == TYPEOF(self.curvewidth)) and (self.curvewidth == 'by layer'))) + if not eval_measureofwidth_wr: + raise AssertionError('Rule measureofwidth violated') + else: + return eval_measureofwidth_wr + + def identifiablecurvestyle(self): + eval_identifiablecurvestyle_wr = ((EXISTS(self.curvefont) or EXISTS(self.curvewidth)) or EXISTS(self.curvecolour)) + if not eval_identifiablecurvestyle_wr: + raise AssertionError('Rule identifiablecurvestyle violated') + else: + return eval_identifiablecurvestyle_wr + + +#################### + # ENTITY ifcdirection # +#################### +class ifcdirection(ifcgeometricrepresentationitem): + '''Entity ifcdirection definition. + + :param directionratios + :type directionratios:LIST(2,3,'REAL', scope = schema_scope) + + :param dim + :type dim:ifcdimensioncount + ''' + def __init__( self , directionratios, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.directionratios = directionratios + + @apply + def directionratios(): + def fget( self ): + return self._directionratios + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directionratios is mantatory and can not be set to None') + if not check_type(value,LIST(2,3,'REAL', scope = schema_scope)): + self._directionratios = LIST(value) + else: + self._directionratios = value + return property(**locals()) + + @apply + def dim(): + def fget( self ): + attribute_eval = HIINDEX(self.directionratios) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument dim is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def magnitudegreaterzero(self): + eval_magnitudegreaterzero_wr = (SIZEOF(None) > 0) + if not eval_magnitudegreaterzero_wr: + raise AssertionError('Rule magnitudegreaterzero violated') + else: + return eval_magnitudegreaterzero_wr + + +#################### + # ENTITY ifcstackterminal # +#################### +class ifcstackterminal(ifcflowterminal): + '''Entity ifcstackterminal definition. + + :param predefinedtype + :type predefinedtype:ifcstackterminaltypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowterminal.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstackterminaltypeenum): + self._predefinedtype = ifcstackterminaltypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcstackterminaltypeenum.self.userdefined)) or ((self.predefinedtype == ifcstackterminaltypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCSTACKTERMINALTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcstructuralloadconfiguration # +#################### +class ifcstructuralloadconfiguration(ifcstructuralload): + '''Entity ifcstructuralloadconfiguration definition. + + :param values + :type values:LIST(1,None,'ifcstructuralloadorresult', scope = schema_scope) + + :param locations + :type locations:LIST(1,None,LIST(1,2,'REAL', scope = schema_scope)) + ''' + def __init__( self , inherited0__name , values,locations, ): + ifcstructuralload.__init__(self , inherited0__name , ) + self.values = values + self.locations = locations + + @apply + def values(): + def fget( self ): + return self._values + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument values is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcstructuralloadorresult', scope = schema_scope)): + self._values = LIST(value) + else: + self._values = value + return property(**locals()) + + @apply + def locations(): + def fget( self ): + return self._locations + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,LIST(1,2,'REAL', scope = schema_scope))): + self._locations = LIST(value) + else: + self._locations = value + else: + self._locations = value + return property(**locals()) + def validlistsize(self): + eval_validlistsize_wr = (( not EXISTS(self.locations)) or (SIZEOF(self.locations) == SIZEOF(self.values))) + if not eval_validlistsize_wr: + raise AssertionError('Rule validlistsize violated') + else: + return eval_validlistsize_wr + + +#################### + # ENTITY ifcbeamstandardcase # +#################### +class ifcbeamstandardcase(ifcbeam): + '''Entity ifcbeamstandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ): + ifcbeam.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ) + def hasmaterialprofilesetusage(self): + eval_hasmaterialprofilesetusage_wr = (SIZEOF(None) == 1) + if not eval_hasmaterialprofilesetusage_wr: + raise AssertionError('Rule hasmaterialprofilesetusage violated') + else: + return eval_hasmaterialprofilesetusage_wr + + +#################### + # ENTITY ifcfillareastyletiles # +#################### +class ifcfillareastyletiles(ifcgeometricrepresentationitem): + '''Entity ifcfillareastyletiles definition. + + :param tilingpattern + :type tilingpattern:LIST(2,2,'ifcvector', scope = schema_scope) + + :param tiles + :type tiles:SET(1,None,'ifcstyleditem', scope = schema_scope) + + :param tilingscale + :type tilingscale:ifcpositiveratiomeasure + ''' + def __init__( self , tilingpattern,tiles,tilingscale, ): + ifcgeometricrepresentationitem.__init__(self , ) + self.tilingpattern = tilingpattern + self.tiles = tiles + self.tilingscale = tilingscale + + @apply + def tilingpattern(): + def fget( self ): + return self._tilingpattern + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tilingpattern is mantatory and can not be set to None') + if not check_type(value,LIST(2,2,'ifcvector', scope = schema_scope)): + self._tilingpattern = LIST(value) + else: + self._tilingpattern = value + return property(**locals()) + + @apply + def tiles(): + def fget( self ): + return self._tiles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tiles is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcstyleditem', scope = schema_scope)): + self._tiles = SET(value) + else: + self._tiles = value + return property(**locals()) + + @apply + def tilingscale(): + def fget( self ): + return self._tilingscale + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument tilingscale is mantatory and can not be set to None') + if not check_type(value,ifcpositiveratiomeasure): + self._tilingscale = ifcpositiveratiomeasure(value) + else: + self._tilingscale = value + return property(**locals()) + +#################### + # ENTITY ifcbeamtype # +#################### +class ifcbeamtype(ifcbuildingelementtype): + '''Entity ifcbeamtype definition. + + :param predefinedtype + :type predefinedtype:ifcbeamtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcbeamtypeenum): + self._predefinedtype = ifcbeamtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcbeamtypeenum.self.userdefined) or ((self.predefinedtype == ifcbeamtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcextrudedareasolidtapered # +#################### +class ifcextrudedareasolidtapered(ifcextrudedareasolid): + '''Entity ifcextrudedareasolidtapered definition. + + :param endsweptarea + :type endsweptarea:ifcprofiledef + ''' + def __init__( self , inherited0__sweptarea , inherited1__position , inherited2__extrudeddirection , inherited3__depth , endsweptarea, ): + ifcextrudedareasolid.__init__(self , inherited0__sweptarea , inherited1__position , inherited2__extrudeddirection , inherited3__depth , ) + self.endsweptarea = endsweptarea + + @apply + def endsweptarea(): + def fget( self ): + return self._endsweptarea + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument endsweptarea is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._endsweptarea = ifcprofiledef(value) + else: + self._endsweptarea = value + return property(**locals()) + def correctprofileassignment(self): + eval_correctprofileassignment_wr = ifctaperedsweptareaprofiles(self.self.ifcsweptareasolid.self.sweptarea,self.self.endsweptarea) + if not eval_correctprofileassignment_wr: + raise AssertionError('Rule correctprofileassignment violated') + else: + return eval_correctprofileassignment_wr + + +#################### + # ENTITY ifclightsourcegoniometric # +#################### +class ifclightsourcegoniometric(ifclightsource): + '''Entity ifclightsourcegoniometric definition. + + :param position + :type position:ifcaxis2placement3d + + :param colourappearance + :type colourappearance:ifccolourrgb + + :param colourtemperature + :type colourtemperature:ifcthermodynamictemperaturemeasure + + :param luminousflux + :type luminousflux:ifcluminousfluxmeasure + + :param lightemissionsource + :type lightemissionsource:ifclightemissionsourceenum + + :param lightdistributiondatasource + :type lightdistributiondatasource:ifclightdistributiondatasourceselect + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , position,colourappearance,colourtemperature,luminousflux,lightemissionsource,lightdistributiondatasource, ): + ifclightsource.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , ) + self.position = position + self.colourappearance = colourappearance + self.colourtemperature = colourtemperature + self.luminousflux = luminousflux + self.lightemissionsource = lightemissionsource + self.lightdistributiondatasource = lightdistributiondatasource + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument position is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement3d): + self._position = ifcaxis2placement3d(value) + else: + self._position = value + return property(**locals()) + + @apply + def colourappearance(): + def fget( self ): + return self._colourappearance + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccolourrgb): + self._colourappearance = ifccolourrgb(value) + else: + self._colourappearance = value + else: + self._colourappearance = value + return property(**locals()) + + @apply + def colourtemperature(): + def fget( self ): + return self._colourtemperature + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument colourtemperature is mantatory and can not be set to None') + if not check_type(value,ifcthermodynamictemperaturemeasure): + self._colourtemperature = ifcthermodynamictemperaturemeasure(value) + else: + self._colourtemperature = value + return property(**locals()) + + @apply + def luminousflux(): + def fget( self ): + return self._luminousflux + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument luminousflux is mantatory and can not be set to None') + if not check_type(value,ifcluminousfluxmeasure): + self._luminousflux = ifcluminousfluxmeasure(value) + else: + self._luminousflux = value + return property(**locals()) + + @apply + def lightemissionsource(): + def fget( self ): + return self._lightemissionsource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lightemissionsource is mantatory and can not be set to None') + if not check_type(value,ifclightemissionsourceenum): + self._lightemissionsource = ifclightemissionsourceenum(value) + else: + self._lightemissionsource = value + return property(**locals()) + + @apply + def lightdistributiondatasource(): + def fget( self ): + return self._lightdistributiondatasource + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lightdistributiondatasource is mantatory and can not be set to None') + if not check_type(value,ifclightdistributiondatasourceselect): + self._lightdistributiondatasource = ifclightdistributiondatasourceselect(value) + else: + self._lightdistributiondatasource = value + return property(**locals()) + +#################### + # ENTITY ifcsensortype # +#################### +class ifcsensortype(ifcdistributioncontrolelementtype): + '''Entity ifcsensortype definition. + + :param predefinedtype + :type predefinedtype:ifcsensortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcdistributioncontrolelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcsensortypeenum): + self._predefinedtype = ifcsensortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcsensortypeenum.self.userdefined) or ((self.predefinedtype == ifcsensortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcrelassignstoactor # +#################### +class ifcrelassignstoactor(ifcrelassigns): + '''Entity ifcrelassignstoactor definition. + + :param relatingactor + :type relatingactor:ifcactor + + :param actingrole + :type actingrole:ifcactorrole + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , relatingactor,actingrole, ): + ifcrelassigns.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , inherited5__relatedobjectstype , ) + self.relatingactor = relatingactor + self.actingrole = actingrole + + @apply + def relatingactor(): + def fget( self ): + return self._relatingactor + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingactor is mantatory and can not be set to None') + if not check_type(value,ifcactor): + self._relatingactor = ifcactor(value) + else: + self._relatingactor = value + return property(**locals()) + + @apply + def actingrole(): + def fget( self ): + return self._actingrole + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorrole): + self._actingrole = ifcactorrole(value) + else: + self._actingrole = value + else: + self._actingrole = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + +#################### + # ENTITY ifcstructuralplanaraction # +#################### +class ifcstructuralplanaraction(ifcstructuralsurfaceaction): + '''Entity ifcstructuralplanaraction definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__projectedortrue , inherited11__predefinedtype , ): + ifcstructuralsurfaceaction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__appliedload , inherited8__globalorlocal , inherited9__destabilizingload , inherited10__projectedortrue , inherited11__predefinedtype , ) + def suitableloadtype(self): + eval_suitableloadtype_wr = (SIZEOF(['IFC4.IFCSTRUCTURALLOADPLANARFORCE','IFC4.IFCSTRUCTURALLOADTEMPERATURE'] * TYPEOF(self.self.ifcstructuralactivity.self.appliedload)) == 1) + if not eval_suitableloadtype_wr: + raise AssertionError('Rule suitableloadtype violated') + else: + return eval_suitableloadtype_wr + + def constpredefinedtype(self): + eval_constpredefinedtype_wr = (self.self.ifcstructuralsurfaceaction.self.predefinedtype == ifcstructuralsurfaceactivitytypeenum.self.const) + if not eval_constpredefinedtype_wr: + raise AssertionError('Rule constpredefinedtype violated') + else: + return eval_constpredefinedtype_wr + + +#################### + # ENTITY ifccylindricalsurface # +#################### +class ifccylindricalsurface(ifcelementarysurface): + '''Entity ifccylindricalsurface definition. + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , radius, ): + ifcelementarysurface.__init__(self , inherited0__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifcpipesegment # +#################### +class ifcpipesegment(ifcflowsegment): + '''Entity ifcpipesegment definition. + + :param predefinedtype + :type predefinedtype:ifcpipesegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowsegment.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpipesegmenttypeenum): + self._predefinedtype = ifcpipesegmenttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcpipesegmenttypeenum.self.userdefined)) or ((self.predefinedtype == ifcpipesegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCPIPESEGMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcslippageconnectioncondition # +#################### +class ifcslippageconnectioncondition(ifcstructuralconnectioncondition): + '''Entity ifcslippageconnectioncondition definition. + + :param slippagex + :type slippagex:ifclengthmeasure + + :param slippagey + :type slippagey:ifclengthmeasure + + :param slippagez + :type slippagez:ifclengthmeasure + ''' + def __init__( self , inherited0__name , slippagex,slippagey,slippagez, ): + ifcstructuralconnectioncondition.__init__(self , inherited0__name , ) + self.slippagex = slippagex + self.slippagey = slippagey + self.slippagez = slippagez + + @apply + def slippagex(): + def fget( self ): + return self._slippagex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._slippagex = ifclengthmeasure(value) + else: + self._slippagex = value + else: + self._slippagex = value + return property(**locals()) + + @apply + def slippagey(): + def fget( self ): + return self._slippagey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._slippagey = ifclengthmeasure(value) + else: + self._slippagey = value + else: + self._slippagey = value + return property(**locals()) + + @apply + def slippagez(): + def fget( self ): + return self._slippagez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._slippagez = ifclengthmeasure(value) + else: + self._slippagez = value + else: + self._slippagez = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralresultgroup # +#################### +class ifcstructuralresultgroup(ifcgroup): + '''Entity ifcstructuralresultgroup definition. + + :param theorytype + :type theorytype:ifcanalysistheorytypeenum + + :param resultforloadgroup + :type resultforloadgroup:ifcstructuralloadgroup + + :param islinear + :type islinear:BOOLEAN + + :param resultgroupfor + :type resultgroupfor:SET(0,1,'ifcstructuralanalysismodel', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , theorytype,resultforloadgroup,islinear, ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.theorytype = theorytype + self.resultforloadgroup = resultforloadgroup + self.islinear = islinear + + @apply + def theorytype(): + def fget( self ): + return self._theorytype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument theorytype is mantatory and can not be set to None') + if not check_type(value,ifcanalysistheorytypeenum): + self._theorytype = ifcanalysistheorytypeenum(value) + else: + self._theorytype = value + return property(**locals()) + + @apply + def resultforloadgroup(): + def fget( self ): + return self._resultforloadgroup + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcstructuralloadgroup): + self._resultforloadgroup = ifcstructuralloadgroup(value) + else: + self._resultforloadgroup = value + else: + self._resultforloadgroup = value + return property(**locals()) + + @apply + def islinear(): + def fget( self ): + return self._islinear + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument islinear is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._islinear = BOOLEAN(value) + else: + self._islinear = value + return property(**locals()) + + @apply + def resultgroupfor(): + def fget( self ): + return self._resultgroupfor + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument resultgroupfor is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def hasobjecttype(self): + eval_hasobjecttype_wr = ((self.theorytype != ifcanalysistheorytypeenum.self.userdefined) or EXISTS(self.self.ifcobject.self.objecttype)) + if not eval_hasobjecttype_wr: + raise AssertionError('Rule hasobjecttype violated') + else: + return eval_hasobjecttype_wr + + +#################### + # ENTITY ifctopologyrepresentation # +#################### +class ifctopologyrepresentation(ifcshapemodel): + '''Entity ifctopologyrepresentation definition. + ''' + def __init__( self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ): + ifcshapemodel.__init__(self , inherited0__contextofitems , inherited1__representationidentifier , inherited2__representationtype , inherited3__items , ) + def wr21(self): + eval_wr21_wr = (SIZEOF(None) == 0) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = EXISTS(self.self.ifcrepresentation.self.representationtype) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + def wr23(self): + eval_wr23_wr = ifctopologyrepresentationtypes(self.self.ifcrepresentation.self.representationtype,self.self.ifcrepresentation.self.items) + if not eval_wr23_wr: + raise AssertionError('Rule wr23 violated') + else: + return eval_wr23_wr + + +#################### + # ENTITY ifcblock # +#################### +class ifcblock(ifccsgprimitive3d): + '''Entity ifcblock definition. + + :param xlength + :type xlength:ifcpositivelengthmeasure + + :param ylength + :type ylength:ifcpositivelengthmeasure + + :param zlength + :type zlength:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , xlength,ylength,zlength, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.xlength = xlength + self.ylength = ylength + self.zlength = zlength + + @apply + def xlength(): + def fget( self ): + return self._xlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument xlength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._xlength = ifcpositivelengthmeasure(value) + else: + self._xlength = value + return property(**locals()) + + @apply + def ylength(): + def fget( self ): + return self._ylength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument ylength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._ylength = ifcpositivelengthmeasure(value) + else: + self._ylength = value + return property(**locals()) + + @apply + def zlength(): + def fget( self ): + return self._zlength + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument zlength is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._zlength = ifcpositivelengthmeasure(value) + else: + self._zlength = value + return property(**locals()) + +#################### + # ENTITY ifcconnectionpointgeometry # +#################### +class ifcconnectionpointgeometry(ifcconnectiongeometry): + '''Entity ifcconnectionpointgeometry definition. + + :param pointonrelatingelement + :type pointonrelatingelement:ifcpointorvertexpoint + + :param pointonrelatedelement + :type pointonrelatedelement:ifcpointorvertexpoint + ''' + def __init__( self , pointonrelatingelement,pointonrelatedelement, ): + ifcconnectiongeometry.__init__(self , ) + self.pointonrelatingelement = pointonrelatingelement + self.pointonrelatedelement = pointonrelatedelement + + @apply + def pointonrelatingelement(): + def fget( self ): + return self._pointonrelatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument pointonrelatingelement is mantatory and can not be set to None') + if not check_type(value,ifcpointorvertexpoint): + self._pointonrelatingelement = ifcpointorvertexpoint(value) + else: + self._pointonrelatingelement = value + return property(**locals()) + + @apply + def pointonrelatedelement(): + def fget( self ): + return self._pointonrelatedelement + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpointorvertexpoint): + self._pointonrelatedelement = ifcpointorvertexpoint(value) + else: + self._pointonrelatedelement = value + else: + self._pointonrelatedelement = value + return property(**locals()) + +#################### + # ENTITY ifcconnectionpointeccentricity # +#################### +class ifcconnectionpointeccentricity(ifcconnectionpointgeometry): + '''Entity ifcconnectionpointeccentricity definition. + + :param eccentricityinx + :type eccentricityinx:ifclengthmeasure + + :param eccentricityiny + :type eccentricityiny:ifclengthmeasure + + :param eccentricityinz + :type eccentricityinz:ifclengthmeasure + ''' + def __init__( self , inherited0__pointonrelatingelement , inherited1__pointonrelatedelement , eccentricityinx,eccentricityiny,eccentricityinz, ): + ifcconnectionpointgeometry.__init__(self , inherited0__pointonrelatingelement , inherited1__pointonrelatedelement , ) + self.eccentricityinx = eccentricityinx + self.eccentricityiny = eccentricityiny + self.eccentricityinz = eccentricityinz + + @apply + def eccentricityinx(): + def fget( self ): + return self._eccentricityinx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._eccentricityinx = ifclengthmeasure(value) + else: + self._eccentricityinx = value + else: + self._eccentricityinx = value + return property(**locals()) + + @apply + def eccentricityiny(): + def fget( self ): + return self._eccentricityiny + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._eccentricityiny = ifclengthmeasure(value) + else: + self._eccentricityiny = value + else: + self._eccentricityiny = value + return property(**locals()) + + @apply + def eccentricityinz(): + def fget( self ): + return self._eccentricityinz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclengthmeasure): + self._eccentricityinz = ifclengthmeasure(value) + else: + self._eccentricityinz = value + else: + self._eccentricityinz = value + return property(**locals()) + +#################### + # ENTITY ifcouterboundarycurve # +#################### +class ifcouterboundarycurve(ifcboundarycurve): + '''Entity ifcouterboundarycurve definition. + ''' + def __init__( self , inherited0__segments , inherited1__selfintersect , ): + ifcboundarycurve.__init__(self , inherited0__segments , inherited1__selfintersect , ) + +#################### + # ENTITY ifcedgeloop # +#################### +class ifcedgeloop(ifcloop): + '''Entity ifcedgeloop definition. + + :param edgelist + :type edgelist:LIST(1,None,'ifcorientededge', scope = schema_scope) + + :param ne + :type ne:INTEGER + ''' + def __init__( self , edgelist, ): + ifcloop.__init__(self , ) + self.edgelist = edgelist + + @apply + def edgelist(): + def fget( self ): + return self._edgelist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument edgelist is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcorientededge', scope = schema_scope)): + self._edgelist = LIST(value) + else: + self._edgelist = value + return property(**locals()) + + @apply + def ne(): + def fget( self ): + attribute_eval = SIZEOF(self.edgelist) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument ne is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def isclosed(self): + eval_isclosed_wr = (self.edgelist[1].self.edgestart == self.edgelist[self.ne].self.edgeend) + if not eval_isclosed_wr: + raise AssertionError('Rule isclosed violated') + else: + return eval_isclosed_wr + + def iscontinuous(self): + eval_iscontinuous_wr = ifcloopheadtotail(self) + if not eval_iscontinuous_wr: + raise AssertionError('Rule iscontinuous violated') + else: + return eval_iscontinuous_wr + + +#################### + # ENTITY ifcrelservicesbuildings # +#################### +class ifcrelservicesbuildings(ifcrelconnects): + '''Entity ifcrelservicesbuildings definition. + + :param relatingsystem + :type relatingsystem:ifcsystem + + :param relatedbuildings + :type relatedbuildings:SET(1,None,'ifcspatialelement', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingsystem,relatedbuildings, ): + ifcrelconnects.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingsystem = relatingsystem + self.relatedbuildings = relatedbuildings + + @apply + def relatingsystem(): + def fget( self ): + return self._relatingsystem + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingsystem is mantatory and can not be set to None') + if not check_type(value,ifcsystem): + self._relatingsystem = ifcsystem(value) + else: + self._relatingsystem = value + return property(**locals()) + + @apply + def relatedbuildings(): + def fget( self ): + return self._relatedbuildings + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedbuildings is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcspatialelement', scope = schema_scope)): + self._relatedbuildings = SET(value) + else: + self._relatedbuildings = value + return property(**locals()) + +#################### + # ENTITY ifctexturecoordinategenerator # +#################### +class ifctexturecoordinategenerator(ifctexturecoordinate): + '''Entity ifctexturecoordinategenerator definition. + + :param mode + :type mode:ifclabel + + :param parameter + :type parameter:LIST(1,None,'REAL', scope = schema_scope) + ''' + def __init__( self , inherited0__maps , mode,parameter, ): + ifctexturecoordinate.__init__(self , inherited0__maps , ) + self.mode = mode + self.parameter = parameter + + @apply + def mode(): + def fget( self ): + return self._mode + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mode is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._mode = ifclabel(value) + else: + self._mode = value + return property(**locals()) + + @apply + def parameter(): + def fget( self ): + return self._parameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'REAL', scope = schema_scope)): + self._parameter = LIST(value) + else: + self._parameter = value + else: + self._parameter = value + return property(**locals()) + +#################### + # ENTITY ifccablecarrierfittingtype # +#################### +class ifccablecarrierfittingtype(ifcflowfittingtype): + '''Entity ifccablecarrierfittingtype definition. + + :param predefinedtype + :type predefinedtype:ifccablecarrierfittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowfittingtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccablecarrierfittingtypeenum): + self._predefinedtype = ifccablecarrierfittingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccablecarrierfittingtypeenum.self.userdefined) or ((self.predefinedtype == ifccablecarrierfittingtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcelementassemblytype # +#################### +class ifcelementassemblytype(ifcelementtype): + '''Entity ifcelementassemblytype definition. + + :param predefinedtype + :type predefinedtype:ifcelementassemblytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcelementassemblytypeenum): + self._predefinedtype = ifcelementassemblytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcelementassemblytypeenum.self.userdefined) or ((self.predefinedtype == ifcelementassemblytypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcductfittingtype # +#################### +class ifcductfittingtype(ifcflowfittingtype): + '''Entity ifcductfittingtype definition. + + :param predefinedtype + :type predefinedtype:ifcductfittingtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowfittingtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcductfittingtypeenum): + self._predefinedtype = ifcductfittingtypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcductfittingtypeenum.self.userdefined) or ((self.predefinedtype == ifcductfittingtypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifclocalplacement # +#################### +class ifclocalplacement(ifcobjectplacement): + '''Entity ifclocalplacement definition. + + :param placementrelto + :type placementrelto:ifcobjectplacement + + :param relativeplacement + :type relativeplacement:ifcaxis2placement + ''' + def __init__( self , placementrelto,relativeplacement, ): + ifcobjectplacement.__init__(self , ) + self.placementrelto = placementrelto + self.relativeplacement = relativeplacement + + @apply + def placementrelto(): + def fget( self ): + return self._placementrelto + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcobjectplacement): + self._placementrelto = ifcobjectplacement(value) + else: + self._placementrelto = value + else: + self._placementrelto = value + return property(**locals()) + + @apply + def relativeplacement(): + def fget( self ): + return self._relativeplacement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relativeplacement is mantatory and can not be set to None') + if not check_type(value,ifcaxis2placement): + self._relativeplacement = ifcaxis2placement(value) + else: + self._relativeplacement = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = ifccorrectlocalplacement(self.relativeplacement,self.placementrelto) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + +#################### + # ENTITY ifcpropertyset # +#################### +class ifcpropertyset(ifcpropertysetdefinition): + '''Entity ifcpropertyset definition. + + :param hasproperties + :type hasproperties:SET(1,None,'ifcproperty', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , hasproperties, ): + ifcpropertysetdefinition.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.hasproperties = hasproperties + + @apply + def hasproperties(): + def fget( self ): + return self._hasproperties + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hasproperties is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcproperty', scope = schema_scope)): + self._hasproperties = SET(value) + else: + self._hasproperties = value + return property(**locals()) + def existsname(self): + eval_existsname_wr = EXISTS(self.self.ifcroot.self.name) + if not eval_existsname_wr: + raise AssertionError('Rule existsname violated') + else: + return eval_existsname_wr + + def uniquepropertynames(self): + eval_uniquepropertynames_wr = ifcuniquepropertyname(self.hasproperties) + if not eval_uniquepropertynames_wr: + raise AssertionError('Rule uniquepropertynames violated') + else: + return eval_uniquepropertynames_wr + + +#################### + # ENTITY ifcstructuralcurvemembervarying # +#################### +class ifcstructuralcurvemembervarying(ifcstructuralcurvemember): + '''Entity ifcstructuralcurvemembervarying definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__predefinedtype , inherited8__axis , ): + ifcstructuralcurvemember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__predefinedtype , inherited8__axis , ) + +#################### + # ENTITY ifcunitaryequipmenttype # +#################### +class ifcunitaryequipmenttype(ifcenergyconversiondevicetype): + '''Entity ifcunitaryequipmenttype definition. + + :param predefinedtype + :type predefinedtype:ifcunitaryequipmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcunitaryequipmenttypeenum): + self._predefinedtype = ifcunitaryequipmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcunitaryequipmenttypeenum.self.userdefined) or ((self.predefinedtype == ifcunitaryequipmenttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifczone # +#################### +class ifczone(ifcsystem): + '''Entity ifczone definition. + + :param longname + :type longname:ifclabel + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , longname, ): + ifcsystem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.longname = longname + + @apply + def longname(): + def fget( self ): + return self._longname + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._longname = ifclabel(value) + else: + self._longname = value + else: + self._longname = value + return property(**locals()) + def wr1(self): + eval_wr1_wr = ((SIZEOF(self.self.ifcgroup.self.isgroupedby) == 0) or (SIZEOF(None) == 0)) + if not eval_wr1_wr: + raise AssertionError('Rule wr1 violated') + else: + return eval_wr1_wr + + +#################### + # ENTITY ifcrelprojectselement # +#################### +class ifcrelprojectselement(ifcreldecomposes): + '''Entity ifcrelprojectselement definition. + + :param relatingelement + :type relatingelement:ifcelement + + :param relatedfeatureelement + :type relatedfeatureelement:ifcfeatureelementaddition + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatingelement,relatedfeatureelement, ): + ifcreldecomposes.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatingelement = relatingelement + self.relatedfeatureelement = relatedfeatureelement + + @apply + def relatingelement(): + def fget( self ): + return self._relatingelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingelement is mantatory and can not be set to None') + if not check_type(value,ifcelement): + self._relatingelement = ifcelement(value) + else: + self._relatingelement = value + return property(**locals()) + + @apply + def relatedfeatureelement(): + def fget( self ): + return self._relatedfeatureelement + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedfeatureelement is mantatory and can not be set to None') + if not check_type(value,ifcfeatureelementaddition): + self._relatedfeatureelement = ifcfeatureelementaddition(value) + else: + self._relatedfeatureelement = value + return property(**locals()) + +#################### + # ENTITY ifcburnertype # +#################### +class ifcburnertype(ifcenergyconversiondevicetype): + '''Entity ifcburnertype definition. + + :param predefinedtype + :type predefinedtype:ifcburnertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcenergyconversiondevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcburnertypeenum): + self._predefinedtype = ifcburnertypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcburnertypeenum.self.userdefined) or ((self.predefinedtype == ifcburnertypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcmotorconnection # +#################### +class ifcmotorconnection(ifcenergyconversiondevice): + '''Entity ifcmotorconnection definition. + + :param predefinedtype + :type predefinedtype:ifcmotorconnectiontypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmotorconnectiontypeenum): + self._predefinedtype = ifcmotorconnectiontypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcmotorconnectiontypeenum.self.userdefined)) or ((self.predefinedtype == ifcmotorconnectiontypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCMOTORCONNECTIONTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcopeningelement # +#################### +class ifcopeningelement(ifcfeatureelementsubtraction): + '''Entity ifcopeningelement definition. + + :param predefinedtype + :type predefinedtype:ifcopeningelementtypeenum + + :param hasfillings + :type hasfillings:SET(0,None,'ifcrelfillselement', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcfeatureelementsubtraction.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcopeningelementtypeenum): + self._predefinedtype = ifcopeningelementtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def hasfillings(): + def fget( self ): + return self._hasfillings + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument hasfillings is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifcopeningstandardcase # +#################### +class ifcopeningstandardcase(ifcopeningelement): + '''Entity ifcopeningstandardcase definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ): + ifcopeningelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , inherited8__predefinedtype , ) + +#################### + # ENTITY ifctanktype # +#################### +class ifctanktype(ifcflowstoragedevicetype): + '''Entity ifctanktype definition. + + :param predefinedtype + :type predefinedtype:ifctanktypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowstoragedevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifctanktypeenum): + self._predefinedtype = ifctanktypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifctanktypeenum.self.userdefined) or ((self.predefinedtype == ifctanktypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcchimneytype # +#################### +class ifcchimneytype(ifcbuildingelementtype): + '''Entity ifcchimneytype definition. + + :param predefinedtype + :type predefinedtype:ifcchimneytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcbuildingelementtype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcchimneytypeenum): + self._predefinedtype = ifcchimneytypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcchimneytypeenum.self.userdefined) or ((self.predefinedtype == ifcchimneytypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcwindowstyle # +#################### +class ifcwindowstyle(ifctypeproduct): + '''Entity ifcwindowstyle definition. + + :param constructiontype + :type constructiontype:ifcwindowstyleconstructionenum + + :param operationtype + :type operationtype:ifcwindowstyleoperationenum + + :param parametertakesprecedence + :type parametertakesprecedence:BOOLEAN + + :param sizeable + :type sizeable:BOOLEAN + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , constructiontype,operationtype,parametertakesprecedence,sizeable, ): + ifctypeproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , ) + self.constructiontype = constructiontype + self.operationtype = operationtype + self.parametertakesprecedence = parametertakesprecedence + self.sizeable = sizeable + + @apply + def constructiontype(): + def fget( self ): + return self._constructiontype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument constructiontype is mantatory and can not be set to None') + if not check_type(value,ifcwindowstyleconstructionenum): + self._constructiontype = ifcwindowstyleconstructionenum(value) + else: + self._constructiontype = value + return property(**locals()) + + @apply + def operationtype(): + def fget( self ): + return self._operationtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument operationtype is mantatory and can not be set to None') + if not check_type(value,ifcwindowstyleoperationenum): + self._operationtype = ifcwindowstyleoperationenum(value) + else: + self._operationtype = value + return property(**locals()) + + @apply + def parametertakesprecedence(): + def fget( self ): + return self._parametertakesprecedence + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument parametertakesprecedence is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._parametertakesprecedence = BOOLEAN(value) + else: + self._parametertakesprecedence = value + return property(**locals()) + + @apply + def sizeable(): + def fget( self ): + return self._sizeable + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument sizeable is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._sizeable = BOOLEAN(value) + else: + self._sizeable = value + return property(**locals()) + +#################### + # ENTITY ifcworkschedule # +#################### +class ifcworkschedule(ifcworkcontrol): + '''Entity ifcworkschedule definition. + + :param predefinedtype + :type predefinedtype:ifcworkscheduletypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__creationdate , inherited7__creators , inherited8__purpose , inherited9__duration , inherited10__totalfloat , inherited11__starttime , inherited12__finishtime , predefinedtype, ): + ifcworkcontrol.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__identification , inherited6__creationdate , inherited7__creators , inherited8__purpose , inherited9__duration , inherited10__totalfloat , inherited11__starttime , inherited12__finishtime , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcworkscheduletypeenum): + self._predefinedtype = ifcworkscheduletypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcworkscheduletypeenum.self.userdefined)) or ((self.predefinedtype == ifcworkscheduletypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcboundaryfacecondition # +#################### +class ifcboundaryfacecondition(ifcboundarycondition): + '''Entity ifcboundaryfacecondition definition. + + :param translationalstiffnessbyareax + :type translationalstiffnessbyareax:ifcmodulusofsubgradereactionselect + + :param translationalstiffnessbyareay + :type translationalstiffnessbyareay:ifcmodulusofsubgradereactionselect + + :param translationalstiffnessbyareaz + :type translationalstiffnessbyareaz:ifcmodulusofsubgradereactionselect + ''' + def __init__( self , inherited0__name , translationalstiffnessbyareax,translationalstiffnessbyareay,translationalstiffnessbyareaz, ): + ifcboundarycondition.__init__(self , inherited0__name , ) + self.translationalstiffnessbyareax = translationalstiffnessbyareax + self.translationalstiffnessbyareay = translationalstiffnessbyareay + self.translationalstiffnessbyareaz = translationalstiffnessbyareaz + + @apply + def translationalstiffnessbyareax(): + def fget( self ): + return self._translationalstiffnessbyareax + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofsubgradereactionselect): + self._translationalstiffnessbyareax = ifcmodulusofsubgradereactionselect(value) + else: + self._translationalstiffnessbyareax = value + else: + self._translationalstiffnessbyareax = value + return property(**locals()) + + @apply + def translationalstiffnessbyareay(): + def fget( self ): + return self._translationalstiffnessbyareay + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofsubgradereactionselect): + self._translationalstiffnessbyareay = ifcmodulusofsubgradereactionselect(value) + else: + self._translationalstiffnessbyareay = value + else: + self._translationalstiffnessbyareay = value + return property(**locals()) + + @apply + def translationalstiffnessbyareaz(): + def fget( self ): + return self._translationalstiffnessbyareaz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmodulusofsubgradereactionselect): + self._translationalstiffnessbyareaz = ifcmodulusofsubgradereactionselect(value) + else: + self._translationalstiffnessbyareaz = value + else: + self._translationalstiffnessbyareaz = value + return property(**locals()) + +#################### + # ENTITY ifcbuildingsystem # +#################### +class ifcbuildingsystem(ifcsystem): + '''Entity ifcbuildingsystem definition. + + :param predefinedtype + :type predefinedtype:ifcbuildingsystemtypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , predefinedtype, ): + ifcsystem.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcbuildingsystemtypeenum): + self._predefinedtype = ifcbuildingsystemtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + +#################### + # ENTITY ifccompositeprofiledef # +#################### +class ifccompositeprofiledef(ifcprofiledef): + '''Entity ifccompositeprofiledef definition. + + :param profiles + :type profiles:SET(2,None,'ifcprofiledef', scope = schema_scope) + + :param label + :type label:ifclabel + ''' + def __init__( self , inherited0__profiletype , inherited1__profilename , profiles,label, ): + ifcprofiledef.__init__(self , inherited0__profiletype , inherited1__profilename , ) + self.profiles = profiles + self.label = label + + @apply + def profiles(): + def fget( self ): + return self._profiles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument profiles is mantatory and can not be set to None') + if not check_type(value,SET(2,None,'ifcprofiledef', scope = schema_scope)): + self._profiles = SET(value) + else: + self._profiles = value + return property(**locals()) + + @apply + def label(): + def fget( self ): + return self._label + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._label = ifclabel(value) + else: + self._label = value + else: + self._label = value + return property(**locals()) + def invariantprofiletype(self): + eval_invariantprofiletype_wr = (SIZEOF(None) == 0) + if not eval_invariantprofiletype_wr: + raise AssertionError('Rule invariantprofiletype violated') + else: + return eval_invariantprofiletype_wr + + def norecursion(self): + eval_norecursion_wr = (SIZEOF(None) == 0) + if not eval_norecursion_wr: + raise AssertionError('Rule norecursion violated') + else: + return eval_norecursion_wr + + +#################### + # ENTITY ifcductsegment # +#################### +class ifcductsegment(ifcflowsegment): + '''Entity ifcductsegment definition. + + :param predefinedtype + :type predefinedtype:ifcductsegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcflowsegment.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcductsegmenttypeenum): + self._predefinedtype = ifcductsegmenttypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcductsegmenttypeenum.self.userdefined)) or ((self.predefinedtype == ifcductsegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCDUCTSEGMENTTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcasset # +#################### +class ifcasset(ifcgroup): + '''Entity ifcasset definition. + + :param identification + :type identification:ifcidentifier + + :param originalvalue + :type originalvalue:ifccostvalue + + :param currentvalue + :type currentvalue:ifccostvalue + + :param totalreplacementcost + :type totalreplacementcost:ifccostvalue + + :param owner + :type owner:ifcactorselect + + :param user + :type user:ifcactorselect + + :param responsibleperson + :type responsibleperson:ifcperson + + :param incorporationdate + :type incorporationdate:ifcdate + + :param depreciatedvalue + :type depreciatedvalue:ifccostvalue + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , identification,originalvalue,currentvalue,totalreplacementcost,owner,user,responsibleperson,incorporationdate,depreciatedvalue, ): + ifcgroup.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , ) + self.identification = identification + self.originalvalue = originalvalue + self.currentvalue = currentvalue + self.totalreplacementcost = totalreplacementcost + self.owner = owner + self.user = user + self.responsibleperson = responsibleperson + self.incorporationdate = incorporationdate + self.depreciatedvalue = depreciatedvalue + + @apply + def identification(): + def fget( self ): + return self._identification + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcidentifier): + self._identification = ifcidentifier(value) + else: + self._identification = value + else: + self._identification = value + return property(**locals()) + + @apply + def originalvalue(): + def fget( self ): + return self._originalvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostvalue): + self._originalvalue = ifccostvalue(value) + else: + self._originalvalue = value + else: + self._originalvalue = value + return property(**locals()) + + @apply + def currentvalue(): + def fget( self ): + return self._currentvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostvalue): + self._currentvalue = ifccostvalue(value) + else: + self._currentvalue = value + else: + self._currentvalue = value + return property(**locals()) + + @apply + def totalreplacementcost(): + def fget( self ): + return self._totalreplacementcost + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostvalue): + self._totalreplacementcost = ifccostvalue(value) + else: + self._totalreplacementcost = value + else: + self._totalreplacementcost = value + return property(**locals()) + + @apply + def owner(): + def fget( self ): + return self._owner + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._owner = ifcactorselect(value) + else: + self._owner = value + else: + self._owner = value + return property(**locals()) + + @apply + def user(): + def fget( self ): + return self._user + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._user = ifcactorselect(value) + else: + self._user = value + else: + self._user = value + return property(**locals()) + + @apply + def responsibleperson(): + def fget( self ): + return self._responsibleperson + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcperson): + self._responsibleperson = ifcperson(value) + else: + self._responsibleperson = value + else: + self._responsibleperson = value + return property(**locals()) + + @apply + def incorporationdate(): + def fget( self ): + return self._incorporationdate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdate): + self._incorporationdate = ifcdate(value) + else: + self._incorporationdate = value + else: + self._incorporationdate = value + return property(**locals()) + + @apply + def depreciatedvalue(): + def fget( self ): + return self._depreciatedvalue + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifccostvalue): + self._depreciatedvalue = ifccostvalue(value) + else: + self._depreciatedvalue = value + else: + self._depreciatedvalue = value + return property(**locals()) + +#################### + # ENTITY ifcirregulartimeseries # +#################### +class ifcirregulartimeseries(ifctimeseries): + '''Entity ifcirregulartimeseries definition. + + :param values + :type values:LIST(1,None,'ifcirregulartimeseriesvalue', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__starttime , inherited3__endtime , inherited4__timeseriesdatatype , inherited5__dataorigin , inherited6__userdefineddataorigin , inherited7__unit , values, ): + ifctimeseries.__init__(self , inherited0__name , inherited1__description , inherited2__starttime , inherited3__endtime , inherited4__timeseriesdatatype , inherited5__dataorigin , inherited6__userdefineddataorigin , inherited7__unit , ) + self.values = values + + @apply + def values(): + def fget( self ): + return self._values + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument values is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcirregulartimeseriesvalue', scope = schema_scope)): + self._values = LIST(value) + else: + self._values = value + return property(**locals()) + +#################### + # ENTITY ifcblobtexture # +#################### +class ifcblobtexture(ifcsurfacetexture): + '''Entity ifcblobtexture definition. + + :param rasterformat + :type rasterformat:ifcidentifier + + :param rastercode + :type rastercode:(null) + ''' + def __init__( self , inherited0__repeats , inherited1__repeatt , inherited2__mode , inherited3__texturetransform , inherited4__parameter , rasterformat,rastercode, ): + ifcsurfacetexture.__init__(self , inherited0__repeats , inherited1__repeatt , inherited2__mode , inherited3__texturetransform , inherited4__parameter , ) + self.rasterformat = rasterformat + self.rastercode = rastercode + + @apply + def rasterformat(): + def fget( self ): + return self._rasterformat + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rasterformat is mantatory and can not be set to None') + if not check_type(value,ifcidentifier): + self._rasterformat = ifcidentifier(value) + else: + self._rasterformat = value + return property(**locals()) + + @apply + def rastercode(): + def fget( self ): + return self._rastercode + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument rastercode is mantatory and can not be set to None') + if not check_type(value,(null)): + self._rastercode = (null)(value) + else: + self._rastercode = value + return property(**locals()) + def supportedrasterformat(self): + eval_supportedrasterformat_wr = (self.self.rasterformat == ['BMP','JPG','GIF','PNG']) + if not eval_supportedrasterformat_wr: + raise AssertionError('Rule supportedrasterformat violated') + else: + return eval_supportedrasterformat_wr + + def rastercodebytestream(self): + eval_rastercodebytestream_wr = ((BLENGTH(self.rastercode) % 8) == 0) + if not eval_rastercodebytestream_wr: + raise AssertionError('Rule rastercodebytestream violated') + else: + return eval_rastercodebytestream_wr + + +#################### + # ENTITY ifclightintensitydistribution # +#################### +class ifclightintensitydistribution(BaseEntityClass): + '''Entity ifclightintensitydistribution definition. + + :param lightdistributioncurve + :type lightdistributioncurve:ifclightdistributioncurveenum + + :param distributiondata + :type distributiondata:LIST(1,None,'ifclightdistributiondata', scope = schema_scope) + ''' + def __init__( self , lightdistributioncurve,distributiondata, ): + self.lightdistributioncurve = lightdistributioncurve + self.distributiondata = distributiondata + + @apply + def lightdistributioncurve(): + def fget( self ): + return self._lightdistributioncurve + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument lightdistributioncurve is mantatory and can not be set to None') + if not check_type(value,ifclightdistributioncurveenum): + self._lightdistributioncurve = ifclightdistributioncurveenum(value) + else: + self._lightdistributioncurve = value + return property(**locals()) + + @apply + def distributiondata(): + def fget( self ): + return self._distributiondata + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument distributiondata is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifclightdistributiondata', scope = schema_scope)): + self._distributiondata = LIST(value) + else: + self._distributiondata = value + return property(**locals()) + +#################### + # ENTITY ifccurveboundedsurface # +#################### +class ifccurveboundedsurface(ifcboundedsurface): + '''Entity ifccurveboundedsurface definition. + + :param basissurface + :type basissurface:ifcsurface + + :param boundaries + :type boundaries:SET(1,None,'ifcboundarycurve', scope = schema_scope) + + :param implicitouter + :type implicitouter:BOOLEAN + ''' + def __init__( self , basissurface,boundaries,implicitouter, ): + ifcboundedsurface.__init__(self , ) + self.basissurface = basissurface + self.boundaries = boundaries + self.implicitouter = implicitouter + + @apply + def basissurface(): + def fget( self ): + return self._basissurface + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument basissurface is mantatory and can not be set to None') + if not check_type(value,ifcsurface): + self._basissurface = ifcsurface(value) + else: + self._basissurface = value + return property(**locals()) + + @apply + def boundaries(): + def fget( self ): + return self._boundaries + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument boundaries is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcboundarycurve', scope = schema_scope)): + self._boundaries = SET(value) + else: + self._boundaries = value + return property(**locals()) + + @apply + def implicitouter(): + def fget( self ): + return self._implicitouter + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument implicitouter is mantatory and can not be set to None') + if not check_type(value,BOOLEAN): + self._implicitouter = BOOLEAN(value) + else: + self._implicitouter = value + return property(**locals()) + +#################### + # ENTITY ifcgrid # +#################### +class ifcgrid(ifcproduct): + '''Entity ifcgrid definition. + + :param uaxes + :type uaxes:LIST(1,None,'ifcgridaxis', scope = schema_scope) + + :param vaxes + :type vaxes:LIST(1,None,'ifcgridaxis', scope = schema_scope) + + :param waxes + :type waxes:LIST(1,None,'ifcgridaxis', scope = schema_scope) + + :param predefinedtype + :type predefinedtype:ifcgridtypeenum + + :param containedinstructure + :type containedinstructure:SET(0,1,'ifcrelcontainedinspatialstructure', scope = schema_scope) + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , uaxes,vaxes,waxes,predefinedtype, ): + ifcproduct.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , ) + self.uaxes = uaxes + self.vaxes = vaxes + self.waxes = waxes + self.predefinedtype = predefinedtype + + @apply + def uaxes(): + def fget( self ): + return self._uaxes + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument uaxes is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcgridaxis', scope = schema_scope)): + self._uaxes = LIST(value) + else: + self._uaxes = value + return property(**locals()) + + @apply + def vaxes(): + def fget( self ): + return self._vaxes + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument vaxes is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifcgridaxis', scope = schema_scope)): + self._vaxes = LIST(value) + else: + self._vaxes = value + return property(**locals()) + + @apply + def waxes(): + def fget( self ): + return self._waxes + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifcgridaxis', scope = schema_scope)): + self._waxes = LIST(value) + else: + self._waxes = value + else: + self._waxes = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcgridtypeenum): + self._predefinedtype = ifcgridtypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + + @apply + def containedinstructure(): + def fget( self ): + return self._containedinstructure + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument containedinstructure is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + def hasplacement(self): + eval_hasplacement_wr = EXISTS(self.self.ifcproduct.self.objectplacement) + if not eval_hasplacement_wr: + raise AssertionError('Rule hasplacement violated') + else: + return eval_hasplacement_wr + + +#################### + # ENTITY ifcmechanicalfastener # +#################### +class ifcmechanicalfastener(ifcelementcomponent): + '''Entity ifcmechanicalfastener definition. + + :param nominaldiameter + :type nominaldiameter:ifcpositivelengthmeasure + + :param nominallength + :type nominallength:ifcpositivelengthmeasure + + :param predefinedtype + :type predefinedtype:ifcmechanicalfastenertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , nominaldiameter,nominallength,predefinedtype, ): + ifcelementcomponent.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.nominaldiameter = nominaldiameter + self.nominallength = nominallength + self.predefinedtype = predefinedtype + + @apply + def nominaldiameter(): + def fget( self ): + return self._nominaldiameter + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominaldiameter = ifcpositivelengthmeasure(value) + else: + self._nominaldiameter = value + else: + self._nominaldiameter = value + return property(**locals()) + + @apply + def nominallength(): + def fget( self ): + return self._nominallength + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcpositivelengthmeasure): + self._nominallength = ifcpositivelengthmeasure(value) + else: + self._nominallength = value + else: + self._nominallength = value + return property(**locals()) + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcmechanicalfastenertypeenum): + self._predefinedtype = ifcmechanicalfastenertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcmechanicalfastenertypeenum.self.userdefined)) or ((self.predefinedtype == ifcmechanicalfastenertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCMECHANICALFASTENERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcphysicalcomplexquantity # +#################### +class ifcphysicalcomplexquantity(ifcphysicalquantity): + '''Entity ifcphysicalcomplexquantity definition. + + :param hasquantities + :type hasquantities:SET(1,None,'ifcphysicalquantity', scope = schema_scope) + + :param discrimination + :type discrimination:ifclabel + + :param quality + :type quality:ifclabel + + :param usage + :type usage:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , hasquantities,discrimination,quality,usage, ): + ifcphysicalquantity.__init__(self , inherited0__name , inherited1__description , ) + self.hasquantities = hasquantities + self.discrimination = discrimination + self.quality = quality + self.usage = usage + + @apply + def hasquantities(): + def fget( self ): + return self._hasquantities + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument hasquantities is mantatory and can not be set to None') + if not check_type(value,SET(1,None,'ifcphysicalquantity', scope = schema_scope)): + self._hasquantities = SET(value) + else: + self._hasquantities = value + return property(**locals()) + + @apply + def discrimination(): + def fget( self ): + return self._discrimination + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument discrimination is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._discrimination = ifclabel(value) + else: + self._discrimination = value + return property(**locals()) + + @apply + def quality(): + def fget( self ): + return self._quality + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._quality = ifclabel(value) + else: + self._quality = value + else: + self._quality = value + return property(**locals()) + + @apply + def usage(): + def fget( self ): + return self._usage + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._usage = ifclabel(value) + else: + self._usage = value + else: + self._usage = value + return property(**locals()) + def noselfreference(self): + eval_noselfreference_wr = (SIZEOF(None) == 0) + if not eval_noselfreference_wr: + raise AssertionError('Rule noselfreference violated') + else: + return eval_noselfreference_wr + + def uniquequantitynames(self): + eval_uniquequantitynames_wr = ifcuniquequantitynames(self.hasquantities) + if not eval_uniquequantitynames_wr: + raise AssertionError('Rule uniquequantitynames violated') + else: + return eval_uniquequantitynames_wr + + +#################### + # ENTITY ifcpresentationlayerwithstyle # +#################### +class ifcpresentationlayerwithstyle(ifcpresentationlayerassignment): + '''Entity ifcpresentationlayerwithstyle definition. + + :param layeron + :type layeron:LOGICAL + + :param layerfrozen + :type layerfrozen:LOGICAL + + :param layerblocked + :type layerblocked:LOGICAL + + :param layerstyles + :type layerstyles:SET(0,None,'ifcpresentationstyle', scope = schema_scope) + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__assigneditems , inherited3__identifier , layeron,layerfrozen,layerblocked,layerstyles, ): + ifcpresentationlayerassignment.__init__(self , inherited0__name , inherited1__description , inherited2__assigneditems , inherited3__identifier , ) + self.layeron = layeron + self.layerfrozen = layerfrozen + self.layerblocked = layerblocked + self.layerstyles = layerstyles + + @apply + def layeron(): + def fget( self ): + return self._layeron + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layeron is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._layeron = LOGICAL(value) + else: + self._layeron = value + return property(**locals()) + + @apply + def layerfrozen(): + def fget( self ): + return self._layerfrozen + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layerfrozen is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._layerfrozen = LOGICAL(value) + else: + self._layerfrozen = value + return property(**locals()) + + @apply + def layerblocked(): + def fget( self ): + return self._layerblocked + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layerblocked is mantatory and can not be set to None') + if not check_type(value,LOGICAL): + self._layerblocked = LOGICAL(value) + else: + self._layerblocked = value + return property(**locals()) + + @apply + def layerstyles(): + def fget( self ): + return self._layerstyles + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument layerstyles is mantatory and can not be set to None') + if not check_type(value,SET(0,None,'ifcpresentationstyle', scope = schema_scope)): + self._layerstyles = SET(value) + else: + self._layerstyles = value + return property(**locals()) + def applicableonlytoitems(self): + eval_applicableonlytoitems_wr = (SIZEOF(None) == SIZEOF(self.assigneditems)) + if not eval_applicableonlytoitems_wr: + raise AssertionError('Rule applicableonlytoitems violated') + else: + return eval_applicableonlytoitems_wr + + +#################### + # ENTITY ifcprojectlibrary # +#################### +class ifcprojectlibrary(ifccontext): + '''Entity ifcprojectlibrary definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__longname , inherited6__phase , inherited7__representationcontexts , inherited8__unitsincontext , ): + ifccontext.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__longname , inherited6__phase , inherited7__representationcontexts , inherited8__unitsincontext , ) + +#################### + # ENTITY ifccompressortype # +#################### +class ifccompressortype(ifcflowmovingdevicetype): + '''Entity ifccompressortype definition. + + :param predefinedtype + :type predefinedtype:ifccompressortypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowmovingdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifccompressortypeenum): + self._predefinedtype = ifccompressortypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifccompressortypeenum.self.userdefined) or ((self.predefinedtype == ifccompressortypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifclightdistributiondata # +#################### +class ifclightdistributiondata(BaseEntityClass): + '''Entity ifclightdistributiondata definition. + + :param mainplaneangle + :type mainplaneangle:ifcplaneanglemeasure + + :param secondaryplaneangle + :type secondaryplaneangle:LIST(1,None,'REAL', scope = schema_scope) + + :param luminousintensity + :type luminousintensity:LIST(1,None,'REAL', scope = schema_scope) + ''' + def __init__( self , mainplaneangle,secondaryplaneangle,luminousintensity, ): + self.mainplaneangle = mainplaneangle + self.secondaryplaneangle = secondaryplaneangle + self.luminousintensity = luminousintensity + + @apply + def mainplaneangle(): + def fget( self ): + return self._mainplaneangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument mainplaneangle is mantatory and can not be set to None') + if not check_type(value,ifcplaneanglemeasure): + self._mainplaneangle = ifcplaneanglemeasure(value) + else: + self._mainplaneangle = value + return property(**locals()) + + @apply + def secondaryplaneangle(): + def fget( self ): + return self._secondaryplaneangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument secondaryplaneangle is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'REAL', scope = schema_scope)): + self._secondaryplaneangle = LIST(value) + else: + self._secondaryplaneangle = value + return property(**locals()) + + @apply + def luminousintensity(): + def fget( self ): + return self._luminousintensity + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument luminousintensity is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'REAL', scope = schema_scope)): + self._luminousintensity = LIST(value) + else: + self._luminousintensity = value + return property(**locals()) + +#################### + # ENTITY ifcpipesegmenttype # +#################### +class ifcpipesegmenttype(ifcflowsegmenttype): + '''Entity ifcpipesegmenttype definition. + + :param predefinedtype + :type predefinedtype:ifcpipesegmenttypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowsegmenttype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcpipesegmenttypeenum): + self._predefinedtype = ifcpipesegmenttypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcpipesegmenttypeenum.self.userdefined) or ((self.predefinedtype == ifcpipesegmenttypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcquantityvolume # +#################### +class ifcquantityvolume(ifcphysicalsimplequantity): + '''Entity ifcquantityvolume definition. + + :param volumevalue + :type volumevalue:ifcvolumemeasure + + :param formula + :type formula:ifclabel + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__unit , volumevalue,formula, ): + ifcphysicalsimplequantity.__init__(self , inherited0__name , inherited1__description , inherited2__unit , ) + self.volumevalue = volumevalue + self.formula = formula + + @apply + def volumevalue(): + def fget( self ): + return self._volumevalue + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument volumevalue is mantatory and can not be set to None') + if not check_type(value,ifcvolumemeasure): + self._volumevalue = ifcvolumemeasure(value) + else: + self._volumevalue = value + return property(**locals()) + + @apply + def formula(): + def fget( self ): + return self._formula + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._formula = ifclabel(value) + else: + self._formula = value + else: + self._formula = value + return property(**locals()) + def wr21(self): + eval_wr21_wr = (( not EXISTS(self.self.ifcphysicalsimplequantity.self.unit)) or (self.self.ifcphysicalsimplequantity.self.unit.self.unittype == ifcunitenum.self.volumeunit)) + if not eval_wr21_wr: + raise AssertionError('Rule wr21 violated') + else: + return eval_wr21_wr + + def wr22(self): + eval_wr22_wr = (self.volumevalue >= 0) + if not eval_wr22_wr: + raise AssertionError('Rule wr22 violated') + else: + return eval_wr22_wr + + +#################### + # ENTITY ifcaxis2placement2d # +#################### +class ifcaxis2placement2d(ifcplacement): + '''Entity ifcaxis2placement2d definition. + + :param refdirection + :type refdirection:ifcdirection + + :param p + :type p:LIST(2,2,'ifcdirection', scope = schema_scope) + ''' + def __init__( self , inherited0__location , refdirection, ): + ifcplacement.__init__(self , inherited0__location , ) + self.refdirection = refdirection + + @apply + def refdirection(): + def fget( self ): + return self._refdirection + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdirection): + self._refdirection = ifcdirection(value) + else: + self._refdirection = value + else: + self._refdirection = value + return property(**locals()) + + @apply + def p(): + def fget( self ): + attribute_eval = ifcbuild2axes(self.refdirection) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument p is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def refdiris2d(self): + eval_refdiris2d_wr = (( not EXISTS(self.refdirection)) or (self.refdirection.self.dim == 2)) + if not eval_refdiris2d_wr: + raise AssertionError('Rule refdiris2d violated') + else: + return eval_refdiris2d_wr + + def locationis2d(self): + eval_locationis2d_wr = (self.self.ifcplacement.self.location.self.dim == 2) + if not eval_locationis2d_wr: + raise AssertionError('Rule locationis2d violated') + else: + return eval_locationis2d_wr + + +#################### + # ENTITY ifcrightcircularcone # +#################### +class ifcrightcircularcone(ifccsgprimitive3d): + '''Entity ifcrightcircularcone definition. + + :param height + :type height:ifcpositivelengthmeasure + + :param bottomradius + :type bottomradius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , height,bottomradius, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.height = height + self.bottomradius = bottomradius + + @apply + def height(): + def fget( self ): + return self._height + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument height is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._height = ifcpositivelengthmeasure(value) + else: + self._height = value + return property(**locals()) + + @apply + def bottomradius(): + def fget( self ): + return self._bottomradius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument bottomradius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._bottomradius = ifcpositivelengthmeasure(value) + else: + self._bottomradius = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralloadlinearforce # +#################### +class ifcstructuralloadlinearforce(ifcstructuralloadstatic): + '''Entity ifcstructuralloadlinearforce definition. + + :param linearforcex + :type linearforcex:ifclinearforcemeasure + + :param linearforcey + :type linearforcey:ifclinearforcemeasure + + :param linearforcez + :type linearforcez:ifclinearforcemeasure + + :param linearmomentx + :type linearmomentx:ifclinearmomentmeasure + + :param linearmomenty + :type linearmomenty:ifclinearmomentmeasure + + :param linearmomentz + :type linearmomentz:ifclinearmomentmeasure + ''' + def __init__( self , inherited0__name , linearforcex,linearforcey,linearforcez,linearmomentx,linearmomenty,linearmomentz, ): + ifcstructuralloadstatic.__init__(self , inherited0__name , ) + self.linearforcex = linearforcex + self.linearforcey = linearforcey + self.linearforcez = linearforcez + self.linearmomentx = linearmomentx + self.linearmomenty = linearmomenty + self.linearmomentz = linearmomentz + + @apply + def linearforcex(): + def fget( self ): + return self._linearforcex + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearforcemeasure): + self._linearforcex = ifclinearforcemeasure(value) + else: + self._linearforcex = value + else: + self._linearforcex = value + return property(**locals()) + + @apply + def linearforcey(): + def fget( self ): + return self._linearforcey + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearforcemeasure): + self._linearforcey = ifclinearforcemeasure(value) + else: + self._linearforcey = value + else: + self._linearforcey = value + return property(**locals()) + + @apply + def linearforcez(): + def fget( self ): + return self._linearforcez + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearforcemeasure): + self._linearforcez = ifclinearforcemeasure(value) + else: + self._linearforcez = value + else: + self._linearforcez = value + return property(**locals()) + + @apply + def linearmomentx(): + def fget( self ): + return self._linearmomentx + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearmomentmeasure): + self._linearmomentx = ifclinearmomentmeasure(value) + else: + self._linearmomentx = value + else: + self._linearmomentx = value + return property(**locals()) + + @apply + def linearmomenty(): + def fget( self ): + return self._linearmomenty + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearmomentmeasure): + self._linearmomenty = ifclinearmomentmeasure(value) + else: + self._linearmomenty = value + else: + self._linearmomenty = value + return property(**locals()) + + @apply + def linearmomentz(): + def fget( self ): + return self._linearmomentz + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclinearmomentmeasure): + self._linearmomentz = ifclinearmomentmeasure(value) + else: + self._linearmomentz = value + else: + self._linearmomentz = value + return property(**locals()) + +#################### + # ENTITY ifcopenshell # +#################### +class ifcopenshell(ifcconnectedfaceset): + '''Entity ifcopenshell definition. + ''' + def __init__( self , inherited0__cfsfaces , ): + ifcconnectedfaceset.__init__(self , inherited0__cfsfaces , ) + +#################### + # ENTITY ifcreldefinesbyproperties # +#################### +class ifcreldefinesbyproperties(ifcreldefines): + '''Entity ifcreldefinesbyproperties definition. + + :param relatedobjects + :type relatedobjects:SET(1,1,'ifcobjectdefinition', scope = schema_scope) + + :param relatingpropertydefinition + :type relatingpropertydefinition:ifcpropertysetdefinitionselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , relatedobjects,relatingpropertydefinition, ): + ifcreldefines.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , ) + self.relatedobjects = relatedobjects + self.relatingpropertydefinition = relatingpropertydefinition + + @apply + def relatedobjects(): + def fget( self ): + return self._relatedobjects + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatedobjects is mantatory and can not be set to None') + if not check_type(value,SET(1,1,'ifcobjectdefinition', scope = schema_scope)): + self._relatedobjects = SET(value) + else: + self._relatedobjects = value + return property(**locals()) + + @apply + def relatingpropertydefinition(): + def fget( self ): + return self._relatingpropertydefinition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingpropertydefinition is mantatory and can not be set to None') + if not check_type(value,ifcpropertysetdefinitionselect): + self._relatingpropertydefinition = ifcpropertysetdefinitionselect(value) + else: + self._relatingpropertydefinition = value + return property(**locals()) + +#################### + # ENTITY ifclibraryinformation # +#################### +class ifclibraryinformation(ifcexternalinformation): + '''Entity ifclibraryinformation definition. + + :param name + :type name:ifclabel + + :param version + :type version:ifclabel + + :param publisher + :type publisher:ifcactorselect + + :param versiondate + :type versiondate:ifcdatetime + + :param location + :type location:ifcurireference + + :param description + :type description:ifctext + + :param libraryinfoforobjects + :type libraryinfoforobjects:SET(0,None,'ifcrelassociateslibrary', scope = schema_scope) + + :param haslibraryreferences + :type haslibraryreferences:SET(0,None,'ifclibraryreference', scope = schema_scope) + ''' + def __init__( self , name,version,publisher,versiondate,location,description, ): + ifcexternalinformation.__init__(self , ) + self.name = name + self.version = version + self.publisher = publisher + self.versiondate = versiondate + self.location = location + self.description = description + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument name is mantatory and can not be set to None') + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + return property(**locals()) + + @apply + def version(): + def fget( self ): + return self._version + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._version = ifclabel(value) + else: + self._version = value + else: + self._version = value + return property(**locals()) + + @apply + def publisher(): + def fget( self ): + return self._publisher + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcactorselect): + self._publisher = ifcactorselect(value) + else: + self._publisher = value + else: + self._publisher = value + return property(**locals()) + + @apply + def versiondate(): + def fget( self ): + return self._versiondate + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcdatetime): + self._versiondate = ifcdatetime(value) + else: + self._versiondate = value + else: + self._versiondate = value + return property(**locals()) + + @apply + def location(): + def fget( self ): + return self._location + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcurireference): + self._location = ifcurireference(value) + else: + self._location = value + else: + self._location = value + return property(**locals()) + + @apply + def description(): + def fget( self ): + return self._description + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctext): + self._description = ifctext(value) + else: + self._description = value + else: + self._description = value + return property(**locals()) + + @apply + def libraryinfoforobjects(): + def fget( self ): + return self._libraryinfoforobjects + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument libraryinfoforobjects is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def haslibraryreferences(): + def fget( self ): + return self._haslibraryreferences + def fset( self, value ): + # INVERSE argument + raise AssertionError('Argument haslibraryreferences is INVERSE. It is computed and can not be set to any value') + return property(**locals()) + +#################### + # ENTITY ifclightsourcespot # +#################### +class ifclightsourcespot(ifclightsourcepositional): + '''Entity ifclightsourcespot definition. + + :param orientation + :type orientation:ifcdirection + + :param concentrationexponent + :type concentrationexponent:ifcreal + + :param spreadangle + :type spreadangle:ifcpositiveplaneanglemeasure + + :param beamwidthangle + :type beamwidthangle:ifcpositiveplaneanglemeasure + ''' + def __init__( self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , inherited4__position , inherited5__radius , inherited6__constantattenuation , inherited7__distanceattenuation , inherited8__quadricattenuation , orientation,concentrationexponent,spreadangle,beamwidthangle, ): + ifclightsourcepositional.__init__(self , inherited0__name , inherited1__lightcolour , inherited2__ambientintensity , inherited3__intensity , inherited4__position , inherited5__radius , inherited6__constantattenuation , inherited7__distanceattenuation , inherited8__quadricattenuation , ) + self.orientation = orientation + self.concentrationexponent = concentrationexponent + self.spreadangle = spreadangle + self.beamwidthangle = beamwidthangle + + @apply + def orientation(): + def fget( self ): + return self._orientation + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument orientation is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._orientation = ifcdirection(value) + else: + self._orientation = value + return property(**locals()) + + @apply + def concentrationexponent(): + def fget( self ): + return self._concentrationexponent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcreal): + self._concentrationexponent = ifcreal(value) + else: + self._concentrationexponent = value + else: + self._concentrationexponent = value + return property(**locals()) + + @apply + def spreadangle(): + def fget( self ): + return self._spreadangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument spreadangle is mantatory and can not be set to None') + if not check_type(value,ifcpositiveplaneanglemeasure): + self._spreadangle = ifcpositiveplaneanglemeasure(value) + else: + self._spreadangle = value + return property(**locals()) + + @apply + def beamwidthangle(): + def fget( self ): + return self._beamwidthangle + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument beamwidthangle is mantatory and can not be set to None') + if not check_type(value,ifcpositiveplaneanglemeasure): + self._beamwidthangle = ifcpositiveplaneanglemeasure(value) + else: + self._beamwidthangle = value + return property(**locals()) + +#################### + # ENTITY ifcrecurrencepattern # +#################### +class ifcrecurrencepattern(BaseEntityClass): + '''Entity ifcrecurrencepattern definition. + + :param recurrencetype + :type recurrencetype:ifcrecurrencetypeenum + + :param daycomponent + :type daycomponent:SET(1,None,'INTEGER', scope = schema_scope) + + :param weekdaycomponent + :type weekdaycomponent:SET(1,None,'INTEGER', scope = schema_scope) + + :param monthcomponent + :type monthcomponent:SET(1,None,'INTEGER', scope = schema_scope) + + :param position + :type position:ifcinteger + + :param interval + :type interval:ifcinteger + + :param occurrences + :type occurrences:ifcinteger + + :param timeperiods + :type timeperiods:LIST(1,None,'ifctimeperiod', scope = schema_scope) + ''' + def __init__( self , recurrencetype,daycomponent,weekdaycomponent,monthcomponent,position,interval,occurrences,timeperiods, ): + self.recurrencetype = recurrencetype + self.daycomponent = daycomponent + self.weekdaycomponent = weekdaycomponent + self.monthcomponent = monthcomponent + self.position = position + self.interval = interval + self.occurrences = occurrences + self.timeperiods = timeperiods + + @apply + def recurrencetype(): + def fget( self ): + return self._recurrencetype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument recurrencetype is mantatory and can not be set to None') + if not check_type(value,ifcrecurrencetypeenum): + self._recurrencetype = ifcrecurrencetypeenum(value) + else: + self._recurrencetype = value + return property(**locals()) + + @apply + def daycomponent(): + def fget( self ): + return self._daycomponent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'INTEGER', scope = schema_scope)): + self._daycomponent = SET(value) + else: + self._daycomponent = value + else: + self._daycomponent = value + return property(**locals()) + + @apply + def weekdaycomponent(): + def fget( self ): + return self._weekdaycomponent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'INTEGER', scope = schema_scope)): + self._weekdaycomponent = SET(value) + else: + self._weekdaycomponent = value + else: + self._weekdaycomponent = value + return property(**locals()) + + @apply + def monthcomponent(): + def fget( self ): + return self._monthcomponent + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,SET(1,None,'INTEGER', scope = schema_scope)): + self._monthcomponent = SET(value) + else: + self._monthcomponent = value + else: + self._monthcomponent = value + return property(**locals()) + + @apply + def position(): + def fget( self ): + return self._position + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcinteger): + self._position = ifcinteger(value) + else: + self._position = value + else: + self._position = value + return property(**locals()) + + @apply + def interval(): + def fget( self ): + return self._interval + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcinteger): + self._interval = ifcinteger(value) + else: + self._interval = value + else: + self._interval = value + return property(**locals()) + + @apply + def occurrences(): + def fget( self ): + return self._occurrences + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcinteger): + self._occurrences = ifcinteger(value) + else: + self._occurrences = value + else: + self._occurrences = value + return property(**locals()) + + @apply + def timeperiods(): + def fget( self ): + return self._timeperiods + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,LIST(1,None,'ifctimeperiod', scope = schema_scope)): + self._timeperiods = LIST(value) + else: + self._timeperiods = value + else: + self._timeperiods = value + return property(**locals()) + +#################### + # ENTITY ifcstructuralsurfacemembervarying # +#################### +class ifcstructuralsurfacemembervarying(ifcstructuralsurfacemember): + '''Entity ifcstructuralsurfacemembervarying definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__predefinedtype , inherited8__thickness , ): + ifcstructuralsurfacemember.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__predefinedtype , inherited8__thickness , ) + +#################### + # ENTITY ifctubebundle # +#################### +class ifctubebundle(ifcenergyconversiondevice): + '''Entity ifctubebundle definition. + + :param predefinedtype + :type predefinedtype:ifctubebundletypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctubebundletypeenum): + self._predefinedtype = ifctubebundletypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifctubebundletypeenum.self.userdefined)) or ((self.predefinedtype == ifctubebundletypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCTUBEBUNDLETYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifcprofileproperties # +#################### +class ifcprofileproperties(ifcextendedproperties): + '''Entity ifcprofileproperties definition. + + :param profiledefinition + :type profiledefinition:ifcprofiledef + ''' + def __init__( self , inherited0__name , inherited1__description , inherited2__properties , profiledefinition, ): + ifcextendedproperties.__init__(self , inherited0__name , inherited1__description , inherited2__properties , ) + self.profiledefinition = profiledefinition + + @apply + def profiledefinition(): + def fget( self ): + return self._profiledefinition + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument profiledefinition is mantatory and can not be set to None') + if not check_type(value,ifcprofiledef): + self._profiledefinition = ifcprofiledef(value) + else: + self._profiledefinition = value + return property(**locals()) + +#################### + # ENTITY ifcrelassociatesdocument # +#################### +class ifcrelassociatesdocument(ifcrelassociates): + '''Entity ifcrelassociatesdocument definition. + + :param relatingdocument + :type relatingdocument:ifcdocumentselect + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , relatingdocument, ): + ifcrelassociates.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__relatedobjects , ) + self.relatingdocument = relatingdocument + + @apply + def relatingdocument(): + def fget( self ): + return self._relatingdocument + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument relatingdocument is mantatory and can not be set to None') + if not check_type(value,ifcdocumentselect): + self._relatingdocument = ifcdocumentselect(value) + else: + self._relatingdocument = value + return property(**locals()) + +#################### + # ENTITY ifcfixedreferencesweptareasolid # +#################### +class ifcfixedreferencesweptareasolid(ifcsweptareasolid): + '''Entity ifcfixedreferencesweptareasolid definition. + + :param directrix + :type directrix:ifccurve + + :param startparam + :type startparam:ifcparametervalue + + :param endparam + :type endparam:ifcparametervalue + + :param fixedreference + :type fixedreference:ifcdirection + ''' + def __init__( self , inherited0__sweptarea , inherited1__position , directrix,startparam,endparam,fixedreference, ): + ifcsweptareasolid.__init__(self , inherited0__sweptarea , inherited1__position , ) + self.directrix = directrix + self.startparam = startparam + self.endparam = endparam + self.fixedreference = fixedreference + + @apply + def directrix(): + def fget( self ): + return self._directrix + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument directrix is mantatory and can not be set to None') + if not check_type(value,ifccurve): + self._directrix = ifccurve(value) + else: + self._directrix = value + return property(**locals()) + + @apply + def startparam(): + def fget( self ): + return self._startparam + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcparametervalue): + self._startparam = ifcparametervalue(value) + else: + self._startparam = value + else: + self._startparam = value + return property(**locals()) + + @apply + def endparam(): + def fget( self ): + return self._endparam + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcparametervalue): + self._endparam = ifcparametervalue(value) + else: + self._endparam = value + else: + self._endparam = value + return property(**locals()) + + @apply + def fixedreference(): + def fget( self ): + return self._fixedreference + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument fixedreference is mantatory and can not be set to None') + if not check_type(value,ifcdirection): + self._fixedreference = ifcdirection(value) + else: + self._fixedreference = value + return property(**locals()) + def directrixbounded(self): + eval_directrixbounded_wr = ((EXISTS(self.startparam) and EXISTS(self.endparam)) or (SIZEOF(['IFC4.IFCCONIC','IFC4.IFCBOUNDEDCURVE'] * TYPEOF(self.directrix)) == 1)) + if not eval_directrixbounded_wr: + raise AssertionError('Rule directrixbounded violated') + else: + return eval_directrixbounded_wr + + +#################### + # ENTITY ifcpumptype # +#################### +class ifcpumptype(ifcflowmovingdevicetype): + '''Entity ifcpumptype definition. + + :param predefinedtype + :type predefinedtype:ifcpumptypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , predefinedtype, ): + ifcflowmovingdevicetype.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__applicableoccurrence , inherited5__haspropertysets , inherited6__representationmaps , inherited7__tag , inherited8__elementtype , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument predefinedtype is mantatory and can not be set to None') + if not check_type(value,ifcpumptypeenum): + self._predefinedtype = ifcpumptypeenum(value) + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((self.predefinedtype != ifcpumptypeenum.self.userdefined) or ((self.predefinedtype == ifcpumptypeenum.self.userdefined) and EXISTS(self.self.ifcelementtype.self.elementtype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + +#################### + # ENTITY ifcsphere # +#################### +class ifcsphere(ifccsgprimitive3d): + '''Entity ifcsphere definition. + + :param radius + :type radius:ifcpositivelengthmeasure + ''' + def __init__( self , inherited0__position , radius, ): + ifccsgprimitive3d.__init__(self , inherited0__position , ) + self.radius = radius + + @apply + def radius(): + def fget( self ): + return self._radius + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument radius is mantatory and can not be set to None') + if not check_type(value,ifcpositivelengthmeasure): + self._radius = ifcpositivelengthmeasure(value) + else: + self._radius = value + return property(**locals()) + +#################### + # ENTITY ifccurvestylefont # +#################### +class ifccurvestylefont(ifcpresentationitem): + '''Entity ifccurvestylefont definition. + + :param name + :type name:ifclabel + + :param patternlist + :type patternlist:LIST(1,None,'ifccurvestylefontpattern', scope = schema_scope) + ''' + def __init__( self , name,patternlist, ): + ifcpresentationitem.__init__(self , ) + self.name = name + self.patternlist = patternlist + + @apply + def name(): + def fget( self ): + return self._name + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifclabel): + self._name = ifclabel(value) + else: + self._name = value + else: + self._name = value + return property(**locals()) + + @apply + def patternlist(): + def fget( self ): + return self._patternlist + def fset( self, value ): + # Mandatory argument + if value==None: + raise AssertionError('Argument patternlist is mantatory and can not be set to None') + if not check_type(value,LIST(1,None,'ifccurvestylefontpattern', scope = schema_scope)): + self._patternlist = LIST(value) + else: + self._patternlist = value + return property(**locals()) + +#################### + # ENTITY ifcramp # +#################### +class ifcramp(ifcbuildingelement): + '''Entity ifcramp definition. + + :param predefinedtype + :type predefinedtype:ifcramptypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcramptypeenum): + self._predefinedtype = ifcramptypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctshapedecomposition(self): + eval_correctshapedecomposition_wr = ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 0) or ((HIINDEX(self.self.ifcobjectdefinition.self.isdecomposedby) == 1) and (( not EXISTS(self.self.ifcproduct.self.representation)) or (EXISTS(self.self.ifcproduct.self.representation) and (SIZEOF(None) == 0))))) + if not eval_correctshapedecomposition_wr: + raise AssertionError('Rule correctshapedecomposition violated') + else: + return eval_correctshapedecomposition_wr + + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcramptypeenum.self.userdefined)) or ((self.predefinedtype == ifcramptypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCRAMPTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifctransformer # +#################### +class ifctransformer(ifcenergyconversiondevice): + '''Entity ifctransformer definition. + + :param predefinedtype + :type predefinedtype:ifctransformertypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcenergyconversiondevice.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifctransformertypeenum): + self._predefinedtype = ifctransformertypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifctransformertypeenum.self.userdefined)) or ((self.predefinedtype == ifctransformertypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCTRANFORMERTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # ENTITY ifccivilelement # +#################### +class ifccivilelement(ifcelement): + '''Entity ifccivilelement definition. + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ): + ifcelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + +#################### + # ENTITY ifccartesiantransformationoperator3dnonuniform # +#################### +class ifccartesiantransformationoperator3dnonuniform(ifccartesiantransformationoperator3d): + '''Entity ifccartesiantransformationoperator3dnonuniform definition. + + :param scale2 + :type scale2:REAL + + :param scale3 + :type scale3:REAL + + :param scl2 + :type scl2:REAL + + :param scl3 + :type scl3:REAL + ''' + def __init__( self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , inherited4__axis3 , scale2,scale3, ): + ifccartesiantransformationoperator3d.__init__(self , inherited0__axis1 , inherited1__axis2 , inherited2__localorigin , inherited3__scale , inherited4__axis3 , ) + self.scale2 = scale2 + self.scale3 = scale3 + + @apply + def scale2(): + def fget( self ): + return self._scale2 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._scale2 = REAL(value) + else: + self._scale2 = value + else: + self._scale2 = value + return property(**locals()) + + @apply + def scale3(): + def fget( self ): + return self._scale3 + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,REAL): + self._scale3 = REAL(value) + else: + self._scale3 = value + else: + self._scale3 = value + return property(**locals()) + + @apply + def scl2(): + def fget( self ): + attribute_eval = NVL(self.scale2,self.self.ifccartesiantransformationoperator.self.scl) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scl2 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + + @apply + def scl3(): + def fget( self ): + attribute_eval = NVL(self.scale3,self.self.ifccartesiantransformationoperator.self.scl) + return attribute_eval + def fset( self, value ): + # DERIVED argument + raise AssertionError('Argument scl3 is DERIVED. It is computed and can not be set to any value') + return property(**locals()) + def scale2greaterzero(self): + eval_scale2greaterzero_wr = (self.scl2 > 0) + if not eval_scale2greaterzero_wr: + raise AssertionError('Rule scale2greaterzero violated') + else: + return eval_scale2greaterzero_wr + + def scale3greaterzero(self): + eval_scale3greaterzero_wr = (self.scl3 > 0) + if not eval_scale3greaterzero_wr: + raise AssertionError('Rule scale3greaterzero violated') + else: + return eval_scale3greaterzero_wr + + +#################### + # ENTITY ifcchimney # +#################### +class ifcchimney(ifcbuildingelement): + '''Entity ifcchimney definition. + + :param predefinedtype + :type predefinedtype:ifcchimneytypeenum + ''' + def __init__( self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , predefinedtype, ): + ifcbuildingelement.__init__(self , inherited0__globalid , inherited1__ownerhistory , inherited2__name , inherited3__description , inherited4__objecttype , inherited5__objectplacement , inherited6__representation , inherited7__tag , ) + self.predefinedtype = predefinedtype + + @apply + def predefinedtype(): + def fget( self ): + return self._predefinedtype + def fset( self, value ): + if value != None: # OPTIONAL attribute + if not check_type(value,ifcchimneytypeenum): + self._predefinedtype = ifcchimneytypeenum(value) + else: + self._predefinedtype = value + else: + self._predefinedtype = value + return property(**locals()) + def correctpredefinedtype(self): + eval_correctpredefinedtype_wr = ((( not EXISTS(self.predefinedtype)) or (self.predefinedtype != ifcchimneytypeenum.self.userdefined)) or ((self.predefinedtype == ifcchimneytypeenum.self.userdefined) and EXISTS(self.self.ifcobject.self.objecttype))) + if not eval_correctpredefinedtype_wr: + raise AssertionError('Rule correctpredefinedtype violated') + else: + return eval_correctpredefinedtype_wr + + def correcttypeassigned(self): + eval_correcttypeassigned_wr = ((SIZEOF(self.istypedby) == 0) or ('IFC4.IFCCHIMNEYTYPE' == TYPEOF(self.self.ifcobject.self.istypedby[1].self.relatingtype))) + if not eval_correcttypeassigned_wr: + raise AssertionError('Rule correcttypeassigned violated') + else: + return eval_correcttypeassigned_wr + + +#################### + # FUNCTION ifcnormalise # +#################### +def ifcnormalise(arg,): + ''' + :param arg + :type arg:ifcvectorordirection + ''' + if ( not EXISTS(arg)): + return None + else: + if ('IFC4.IFCVECTOR' == TYPEOF(arg)): + # begin/end block + ndim = arg.ifcvector.dim + v.directionratios = arg.ifcvector.orientation.directionratios + vec.magnitude = arg.ifcvector.magnitude + vec.orientation = v + if (arg.ifcvector.magnitude == 0): + return None + else: + vec.magnitude = 1 + else: + # begin/end block + ndim = arg.ifcdirection.dim + v.directionratios = arg.ifcdirection.directionratios + mag = 0 + for i in range(1,ndim,1): + mag = mag + (v.directionratios[i] * v.directionratios[i]) + if (mag > 0): + mag = SQRT(mag) + for i in range(1,ndim,1): + v.directionratios[i] = v.directionratios[i] / mag + if ('IFC4.IFCVECTOR' == TYPEOF(arg)): + vec.orientation = v + result = vec + else: + result = v + else: + return None + return result + +#################### + # FUNCTION ifctaperedsweptareaprofiles # +#################### +def ifctaperedsweptareaprofiles(startarea,endarea,): + ''' + :param startarea + :type startarea:ifcprofiledef + :param endarea + :type endarea:ifcprofiledef + ''' + if ('IFC4.IFCPARAMETERIZEDPROFILEDEF' == TYPEOF(startarea)): + if ('IFC4.IFCDERIVEDPROFILEDEF' == TYPEOF(endarea)): + result = startarea == endarea.ifcderivedprofiledef.parentprofile + else: + result = TYPEOF(startarea) == TYPEOF(endarea) + else: + if ('IFC4.IFCDERIVEDPROFILEDEF' == TYPEOF(endarea)): + result = startarea == endarea.ifcderivedprofiledef.parentprofile + else: + result = FALSE + return result + +#################### + # FUNCTION ifcsamevalue # +#################### +def ifcsamevalue(value1,value2,epsilon,): + ''' + :param value1 + :type value1:REAL + :param value2 + :type value2:REAL + :param epsilon + :type epsilon:REAL + ''' + valideps = NVL(epsilon,defaulteps) + return ((value1 + valideps) > value2) and (value1 < (value2 + valideps)) + +#################### + # FUNCTION ifcsamevalidprecision # +#################### +def ifcsamevalidprecision(epsilon1,epsilon2,): + ''' + :param epsilon1 + :type epsilon1:REAL + :param epsilon2 + :type epsilon2:REAL + ''' + valideps1 = NVL(epsilon1,defaulteps) + valideps2 = NVL(epsilon2,defaulteps) + return (((0 < valideps1) and (valideps1 <= (derivationofeps * valideps2))) and (valideps2 <= (derivationofeps * valideps1))) and (valideps2 < uppereps) + +#################### + # FUNCTION ifcbuildaxes # +#################### +def ifcbuildaxes(axis,refdirection,): + ''' + :param axis + :type axis:ifcdirection + :param refdirection + :type refdirection:ifcdirection + ''' + d1 = NVL(ifcnormalise(axis),(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,0,1])) + d2 = ifcfirstprojaxis(d1,refdirection) + return [d2,ifcnormalise(ifccrossproduct(d1,d2)).ifcvector.orientation,d1] + +#################### + # FUNCTION ifcvectorsum # +#################### +def ifcvectorsum(arg1,arg2,): + ''' + :param arg1 + :type arg1:ifcvectorordirection + :param arg2 + :type arg2:ifcvectorordirection + ''' + if ((( not EXISTS(arg1)) or ( not EXISTS(arg2))) or (arg1.dim != arg2.dim)): + return None + else: + # begin/end block + if ('IFC4.IFCVECTOR' == TYPEOF(arg1)): + mag1 = arg1.ifcvector.magnitude + vec1 = arg1.ifcvector.orientation + else: + mag1 = 1 + vec1 = arg1 + if ('IFC4.IFCVECTOR' == TYPEOF(arg2)): + mag2 = arg2.ifcvector.magnitude + vec2 = arg2.ifcvector.orientation + else: + mag2 = 1 + vec2 = arg2 + vec1 = ifcnormalise(vec1) + vec2 = ifcnormalise(vec2) + ndim = SIZEOF(vec1.directionratios) + mag = 0 + res = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,ndim]) + for i in range(1,ndim,1): + res.directionratios[i] = (mag1 * vec1.directionratios[i]) + (mag2 * vec2.directionratios[i]) + mag = mag + (res.directionratios[i] * res.directionratios[i]) + if (mag > 0): + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(res,SQRT(mag)) + else: + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(vec1,0) + return result + +#################### + # FUNCTION ifcvectordifference # +#################### +def ifcvectordifference(arg1,arg2,): + ''' + :param arg1 + :type arg1:ifcvectorordirection + :param arg2 + :type arg2:ifcvectorordirection + ''' + if ((( not EXISTS(arg1)) or ( not EXISTS(arg2))) or (arg1.dim != arg2.dim)): + return None + else: + # begin/end block + if ('IFC4.IFCVECTOR' == TYPEOF(arg1)): + mag1 = arg1.ifcvector.magnitude + vec1 = arg1.ifcvector.orientation + else: + mag1 = 1 + vec1 = arg1 + if ('IFC4.IFCVECTOR' == TYPEOF(arg2)): + mag2 = arg2.ifcvector.magnitude + vec2 = arg2.ifcvector.orientation + else: + mag2 = 1 + vec2 = arg2 + vec1 = ifcnormalise(vec1) + vec2 = ifcnormalise(vec2) + ndim = SIZEOF(vec1.directionratios) + mag = 0 + res = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,ndim]) + for i in range(1,ndim,1): + res.directionratios[i] = (mag1 * vec1.directionratios[i]) - (mag2 * vec2.directionratios[i]) + mag = mag + (res.directionratios[i] * res.directionratios[i]) + if (mag > 0): + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(res,SQRT(mag)) + else: + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(vec1,0) + return result + +#################### + # FUNCTION ifccorrectlocalplacement # +#################### +def ifccorrectlocalplacement(axisplacement,relplacement,): + ''' + :param axisplacement + :type axisplacement:ifcaxis2placement + :param relplacement + :type relplacement:ifcobjectplacement + ''' + if (EXISTS(relplacement)): + if ('IFC4.IFCGRIDPLACEMENT' == TYPEOF(relplacement)): + return None + if ('IFC4.IFCLOCALPLACEMENT' == TYPEOF(relplacement)): + if ('IFC4.IFCAXIS2PLACEMENT2D' == TYPEOF(axisplacement)): + return TRUE + if ('IFC4.IFCAXIS2PLACEMENT3D' == TYPEOF(axisplacement)): + if (relplacement.ifclocalplacement.relativeplacement.dim == 3): + return TRUE + else: + return FALSE + else: + return TRUE + return None + +#################### + # FUNCTION ifccorrectfillareastyle # +#################### +def ifccorrectfillareastyle(styles,): + ''' + :param styles + :type styles:(null) + ''' + external = SIZEOF(None) + hatching = SIZEOF(None) + tiles = SIZEOF(None) + colour = SIZEOF(None) + 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 + +#################### + # FUNCTION ifcuniquepropertytemplatenames # +#################### +def ifcuniquepropertytemplatenames(properties,): + ''' + :param properties + :type properties:(null) + ''' + for i in range(1,HIINDEX(properties),1): + names = names + properties[i].name + return SIZEOF(names) == SIZEOF(properties) + +#################### + # FUNCTION ifcuniquepropertyname # +#################### +def ifcuniquepropertyname(properties,): + ''' + :param properties + :type properties:(null) + ''' + for i in range(1,HIINDEX(properties),1): + names = names + properties[i].name + return SIZEOF(names) == SIZEOF(properties) + +#################### + # FUNCTION ifcmakearrayofarray # +#################### +def ifcmakearrayofarray(lis,low1,u1,low2,u2,): + ''' + :param lis + :type lis:(null) + :param low1 + :type low1:INTEGER + :param u1 + :type u1:INTEGER + :param low2 + :type low2:INTEGER + :param u2 + :type u2:INTEGER + ''' + if (((u1 - low1) + 1) != SIZEOF(lis)): + return None + if (((u2 - low2) + 1) != SIZEOF(lis[1])): + return None + res = [ifclisttoarray(lis[1],low2,u2),(u1 - low1) + 1] + for i in range(2,HIINDEX(lis),1): + if (((u2 - low2) + 1) != SIZEOF(lis[i])): + return None + res[(low1 + i) - 1] = ifclisttoarray(lis[i],low2,u2) + return res + +#################### + # FUNCTION ifccurvedim # +#################### +def ifccurvedim(curve,): + ''' + :param curve + :type curve:ifccurve + ''' + if ('IFC4.IFCLINE' == TYPEOF(curve)): + return curve.ifcline.pnt.dim + if ('IFC4.IFCCONIC' == TYPEOF(curve)): + return curve.ifcconic.position.dim + if ('IFC4.IFCPOLYLINE' == TYPEOF(curve)): + return curve.ifcpolyline.points[1].dim + if ('IFC4.IFCTRIMMEDCURVE' == TYPEOF(curve)): + return ifccurvedim(curve.ifctrimmedcurve.basiscurve) + if ('IFC4.IFCCOMPOSITECURVE' == TYPEOF(curve)): + return curve.ifccompositecurve.segments[1].dim + if ('IFC4.IFCBSPLINECURVE' == TYPEOF(curve)): + return curve.ifcbsplinecurve.controlpointslist[1].dim + if ('IFC4.IFCOFFSETCURVE2D' == TYPEOF(curve)): + return 2 + if ('IFC4.IFCOFFSETCURVE3D' == TYPEOF(curve)): + return 3 + if ('IFC4.IFCPCURVE' == TYPEOF(curve)): + return 3 + return None + +#################### + # FUNCTION ifcsamedirection # +#################### +def ifcsamedirection(dir1,dir2,epsilon,): + ''' + :param dir1 + :type dir1:ifcdirection + :param dir2 + :type dir2:ifcdirection + :param epsilon + :type epsilon:REAL + ''' + if (SIZEOF(dir1.directionratios) > 2): + dir1z = dir1.directionratios[3] + if (SIZEOF(dir2.directionratios) > 2): + dir2z = dir2.directionratios[3] + return (ifcsamevalue(dir1x,dir2x,epsilon) and ifcsamevalue(dir1y,dir2y,epsilon)) and ifcsamevalue(dir1z,dir2z,epsilon) + +#################### + # FUNCTION ifclisttoarray # +#################### +def ifclisttoarray(lis,low,u,): + ''' + :param lis + :type lis:(null) + :param low + :type low:INTEGER + :param u + :type u:INTEGER + ''' + n = SIZEOF(lis) + if (n != ((u - low) + 1)): + return None + else: + res = [lis[1],n] + for i in range(2,n,1): + res[(low + i) - 1] = lis[i] + return res + +#################### + # FUNCTION ifctopologyrepresentationtypes # +#################### +def ifctopologyrepresentationtypes(reptype,items,): + ''' + :param reptype + :type reptype:STRING + :param items + :type items:(null) + ''' + case_selector = reptype + if case_selector == 'Vertex': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Edge': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Path': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Face': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Shell': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Undefined': + return TRUE + else: + return None + return count == SIZEOF(items) + +#################### + # FUNCTION ifccorrectunitassignment # +#################### +def ifccorrectunitassignment(units,): + ''' + :param units + :type units:(null) + ''' + namedunitnumber = SIZEOF(None) + derivedunitnumber = SIZEOF(None) + monetaryunitnumber = SIZEOF(None) + for i in range(1,SIZEOF(units),1): + if (('IFC4.IFCNAMEDUNIT' == TYPEOF(units[i])) and ( not (units[i].ifcnamedunit.unittype == ifcunitenum.userdefined))): + namedunitnames = namedunitnames + units[i].ifcnamedunit.unittype + if (('IFC4.IFCDERIVEDUNIT' == TYPEOF(units[i])) and ( not (units[i].ifcderivedunit.unittype == ifcderivedunitenum.userdefined))): + derivedunitnames = derivedunitnames + units[i].ifcderivedunit.unittype + return ((SIZEOF(namedunitnames) == namedunitnumber) and (SIZEOF(derivedunitnames) == derivedunitnumber)) and (monetaryunitnumber <= 1) + +#################### + # FUNCTION ifcdotproduct # +#################### +def ifcdotproduct(arg1,arg2,): + ''' + :param arg1 + :type arg1:ifcdirection + :param arg2 + :type arg2:ifcdirection + ''' + if (( not EXISTS(arg1)) or ( not EXISTS(arg2))): + scalar = None + else: + if (arg1.dim != arg2.dim): + scalar = None + else: + # begin/end block + vec1 = ifcnormalise(arg1) + vec2 = ifcnormalise(arg2) + ndim = arg1.dim + scalar = 0 + for i in range(1,ndim,1): + scalar = scalar + (vec1.directionratios[i] * vec2.directionratios[i]) + return scalar + +#################### + # FUNCTION ifcfirstprojaxis # +#################### +def ifcfirstprojaxis(zaxis,arg,): + ''' + :param zaxis + :type zaxis:ifcdirection + :param arg + :type arg:ifcdirection + ''' + if ( not EXISTS(zaxis)): + return None + else: + z = ifcnormalise(zaxis) + if ( not EXISTS(arg)): + if (z.directionratios != [1,0,0]): + v = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([1,0,0]) + else: + v = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,1,0]) + else: + if (arg.dim != 3): + return None + if (ifccrossproduct(arg,z).magnitude == 0): + return None + else: + v = ifcnormalise(arg) + xvec = ifcscalartimesvector(ifcdotproduct(v,z),z) + xaxis = ifcvectordifference(v,xvec).orientation + xaxis = ifcnormalise(xaxis) + return xaxis + +#################### + # FUNCTION ifcshaperepresentationtypes # +#################### +def ifcshaperepresentationtypes(reptype,items,): + ''' + :param reptype + :type reptype:STRING + :param items + :type items:(null) + ''' + case_selector = reptype + if case_selector == 'Point': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'PointCloud': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Curve': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Curve2D': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Curve3D': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Surface': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Surface2D': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Surface3D': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'FillArea': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Text': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'AdvancedSurface': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Annotation2D': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'GeometricSet': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'GeometricCurveSet': + # begin/end block + count = SIZEOF(None) + for i in range(1,HIINDEX(items),1): + if ('IFC4.IFCGEOMETRICSET' == TYPEOF(items[i])): + if (SIZEOF(None) > 0): + count = count - 1 + elif case_selector == 'Tessellation': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'SurfaceOrSolidModel': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'SurfaceModel': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'SolidModel': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'SweptSolid': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'AdvancedSweptSolid': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'CSG': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Clipping': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'Brep': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'AdvancedBrep': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'BoundingBox': + # begin/end block + count = SIZEOF(None) + if (SIZEOF(items) > 1): + count = 0 + elif case_selector == 'SectionedSpine': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'LightSource': + # begin/end block + count = SIZEOF(None) + elif case_selector == 'MappedRepresentation': + # begin/end block + count = SIZEOF(None) + else: + return None + return count == SIZEOF(items) + +#################### + # FUNCTION ifcpathheadtotail # +#################### +def ifcpathheadtotail(apath,): + ''' + :param apath + :type apath:ifcpath + ''' + n = SIZEOF(apath.edgelist) + for i in range(2,n,1): + p = p and (apath.edgelist[i - 1].edgeend == apath.edgelist[i].edgestart) + return p + +#################### + # FUNCTION ifcsecondprojaxis # +#################### +def ifcsecondprojaxis(zaxis,xaxis,arg,): + ''' + :param zaxis + :type zaxis:ifcdirection + :param xaxis + :type xaxis:ifcdirection + :param arg + :type arg:ifcdirection + ''' + if ( not EXISTS(arg)): + v = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,1,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 + +#################### + # FUNCTION ifcderivedimensionalexponents # +#################### +def ifcderivedimensionalexponents(unitelements,): + ''' + :param unitelements + :type unitelements:(null) + ''' + for i in range(LOINDEX(unitelements),HIINDEX(unitelements),1): + result.lengthexponent = result.lengthexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.lengthexponent) + result.massexponent = result.massexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.massexponent) + result.timeexponent = result.timeexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.timeexponent) + result.electriccurrentexponent = result.electriccurrentexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.electriccurrentexponent) + result.thermodynamictemperatureexponent = result.thermodynamictemperatureexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.thermodynamictemperatureexponent) + result.amountofsubstanceexponent = result.amountofsubstanceexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.amountofsubstanceexponent) + result.luminousintensityexponent = result.luminousintensityexponent + (unitelements[i].exponent * unitelements[i].unit.dimensions.luminousintensityexponent) + return result + +#################### + # FUNCTION ifcbooleanchoose # +#################### +def ifcbooleanchoose(b,choice1,choice2,): + ''' + :param b + :type b:BOOLEAN + :param choice1 + :type choice1:(null) + :param choice2 + :type choice2:(null) + ''' + if (b): + return choice1 + else: + return choice2 + +#################### + # FUNCTION ifcscalartimesvector # +#################### +def ifcscalartimesvector(scalar,vec,): + ''' + :param scalar + :type scalar:REAL + :param vec + :type vec:ifcvectorordirection + ''' + if (( not EXISTS(scalar)) or ( not EXISTS(vec))): + return None + else: + if ('IFC4.IFCVECTOR' == TYPEOF(vec)): + v = vec.ifcvector.orientation + mag = scalar * vec.ifcvector.magnitude + else: + v = vec + mag = scalar + if (mag < 0): + for i in range(1,SIZEOF(v.directionratios),1): + v.directionratios[i] = -v.directionratios[i] + mag = -mag + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(ifcnormalise(v),mag) + return result + +#################### + # FUNCTION ifcgetbasissurface # +#################### +def ifcgetbasissurface(c,): + ''' + :param c + :type c:ifccurveonsurface + ''' + surfs = [] + if ('IFC4.IFCPCURVE' == TYPEOF(c)): + surfs = [c.ifcpcurve.basissurface] + else: + if ('IFC4.IFCCOMPOSITECURVEONSURFACE' == TYPEOF(c)): + n = SIZEOF(c.ifccompositecurve.segments) + surfs = ifcgetbasissurface(c.ifccompositecurve.segments[1].parentcurve) + if (n > 1): + for i in range(2,n,1): + surfs = surfs * ifcgetbasissurface(c.ifccompositecurve.segments[1].parentcurve) + return surfs + +#################### + # FUNCTION ifcuniquequantitynames # +#################### +def ifcuniquequantitynames(properties,): + ''' + :param properties + :type properties:(null) + ''' + for i in range(1,HIINDEX(properties),1): + names = names + properties[i].name + return SIZEOF(names) == SIZEOF(properties) + +#################### + # FUNCTION ifcbaseaxis # +#################### +def ifcbaseaxis(dim,axis1,axis2,axis3,): + ''' + :param dim + :type dim:INTEGER + :param axis1 + :type axis1:ifcdirection + :param axis2 + :type axis2:ifcdirection + :param axis3 + :type axis3:ifcdirection + ''' + if (dim == 3): + d1 = NVL(ifcnormalise(axis3),(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,0,1])) + 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]) + if (factor < 0): + u[2].directionratios[1] = -u[2].directionratios[1] + u[2].directionratios[2] = -u[2].directionratios[2] + else: + if (EXISTS(axis2)): + d1 = ifcnormalise(axis2) + u = [ifcorthogonalcomplement(d1),d1] + u[1].directionratios[1] = -u[1].directionratios[1] + u[1].directionratios[2] = -u[1].directionratios[2] + else: + u = [(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([1,0]),(ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([0,1])] + return u + +#################### + # FUNCTION ifcconvertdirectioninto2d # +#################### +def ifcconvertdirectioninto2d(direction,): + ''' + :param direction + :type direction:ifcdirection + ''' + direction2d.directionratios[1] = direction.directionratios[1] + direction2d.directionratios[2] = direction.directionratios[2] + return direction2d + +#################### + # FUNCTION ifcorthogonalcomplement # +#################### +def ifcorthogonalcomplement(vec,): + ''' + :param vec + :type vec:ifcdirection + ''' + if (( not EXISTS(vec)) or (vec.dim != 2)): + return None + else: + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([-vec.directionratios[2],vec.directionratios[1]]) + return result + +#################### + # FUNCTION ifcloopheadtotail # +#################### +def ifcloopheadtotail(aloop,): + ''' + :param aloop + :type aloop:ifcedgeloop + ''' + n = SIZEOF(aloop.edgelist) + for i in range(2,n,1): + p = p and (aloop.edgelist[i - 1].edgeend == aloop.edgelist[i].edgestart) + return p + +#################### + # FUNCTION ifccorrectdimensions # +#################### +def ifccorrectdimensions(m,dim,): + ''' + :param m + :type m:ifcunitenum + :param dim + :type dim:ifcdimensionalexponents + ''' + case_selector = m + if case_selector == lengthunit: + if (dim == ifcdimensionalexponents(1,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == massunit: + if (dim == ifcdimensionalexponents(0,1,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == timeunit: + if (dim == ifcdimensionalexponents(0,0,1,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electriccurrentunit: + if (dim == ifcdimensionalexponents(0,0,0,1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == thermodynamictemperatureunit: + if (dim == ifcdimensionalexponents(0,0,0,0,1,0,0)): + return TRUE + else: + return FALSE + elif case_selector == amountofsubstanceunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,1,0)): + return TRUE + else: + return FALSE + elif case_selector == luminousintensityunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,0,1)): + return TRUE + else: + return FALSE + elif case_selector == planeangleunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == solidangleunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == areaunit: + if (dim == ifcdimensionalexponents(2,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == volumeunit: + if (dim == ifcdimensionalexponents(3,0,0,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == absorbeddoseunit: + if (dim == ifcdimensionalexponents(2,0,-2,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == radioactivityunit: + if (dim == ifcdimensionalexponents(0,0,-1,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electriccapacitanceunit: + if (dim == ifcdimensionalexponents(-2,-1,4,2,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == doseequivalentunit: + if (dim == ifcdimensionalexponents(2,0,-2,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electricchargeunit: + if (dim == ifcdimensionalexponents(0,0,1,1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electricconductanceunit: + if (dim == ifcdimensionalexponents(-2,-1,3,2,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electricvoltageunit: + if (dim == ifcdimensionalexponents(2,1,-3,-1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == electricresistanceunit: + if (dim == ifcdimensionalexponents(2,1,-3,-2,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == energyunit: + if (dim == ifcdimensionalexponents(2,1,-2,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == forceunit: + if (dim == ifcdimensionalexponents(1,1,-2,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == frequencyunit: + if (dim == ifcdimensionalexponents(0,0,-1,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == inductanceunit: + if (dim == ifcdimensionalexponents(2,1,-2,-2,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == illuminanceunit: + if (dim == ifcdimensionalexponents(-2,0,0,0,0,0,1)): + return TRUE + else: + return FALSE + elif case_selector == luminousfluxunit: + if (dim == ifcdimensionalexponents(0,0,0,0,0,0,1)): + return TRUE + else: + return FALSE + elif case_selector == magneticfluxunit: + if (dim == ifcdimensionalexponents(2,1,-2,-1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == magneticfluxdensityunit: + if (dim == ifcdimensionalexponents(0,1,-2,-1,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == powerunit: + if (dim == ifcdimensionalexponents(2,1,-3,0,0,0,0)): + return TRUE + else: + return FALSE + elif case_selector == pressureunit: + if (dim == ifcdimensionalexponents(-1,1,-2,0,0,0,0)): + return TRUE + else: + return FALSE + else: + return UNKNOWN + +#################### + # FUNCTION ifcdimensionsforsiunit # +#################### +def ifcdimensionsforsiunit(n,): + ''' + :param n + :type n:ifcsiunitname + ''' + case_selector = n + if case_selector == metre: + return ifcdimensionalexponents(1,0,0,0,0,0,0) + elif case_selector == square_metre: + return ifcdimensionalexponents(2,0,0,0,0,0,0) + elif case_selector == cubic_metre: + return ifcdimensionalexponents(3,0,0,0,0,0,0) + elif case_selector == gram: + return ifcdimensionalexponents(0,1,0,0,0,0,0) + elif case_selector == second: + return ifcdimensionalexponents(0,0,1,0,0,0,0) + elif case_selector == ampere: + return ifcdimensionalexponents(0,0,0,1,0,0,0) + elif case_selector == kelvin: + return ifcdimensionalexponents(0,0,0,0,1,0,0) + elif case_selector == mole: + return ifcdimensionalexponents(0,0,0,0,0,1,0) + elif case_selector == candela: + return ifcdimensionalexponents(0,0,0,0,0,0,1) + elif case_selector == radian: + return ifcdimensionalexponents(0,0,0,0,0,0,0) + elif case_selector == steradian: + return ifcdimensionalexponents(0,0,0,0,0,0,0) + elif case_selector == hertz: + return ifcdimensionalexponents(0,0,-1,0,0,0,0) + elif case_selector == newton: + return ifcdimensionalexponents(1,1,-2,0,0,0,0) + elif case_selector == pascal: + return ifcdimensionalexponents(-1,1,-2,0,0,0,0) + elif case_selector == joule: + return ifcdimensionalexponents(2,1,-2,0,0,0,0) + elif case_selector == watt: + return ifcdimensionalexponents(2,1,-3,0,0,0,0) + elif case_selector == coulomb: + return ifcdimensionalexponents(0,0,1,1,0,0,0) + elif case_selector == volt: + return ifcdimensionalexponents(2,1,-3,-1,0,0,0) + elif case_selector == farad: + return ifcdimensionalexponents(-2,-1,4,2,0,0,0) + elif case_selector == ohm: + return ifcdimensionalexponents(2,1,-3,-2,0,0,0) + elif case_selector == siemens: + return ifcdimensionalexponents(-2,-1,3,2,0,0,0) + elif case_selector == weber: + return ifcdimensionalexponents(2,1,-2,-1,0,0,0) + elif case_selector == tesla: + return ifcdimensionalexponents(0,1,-2,-1,0,0,0) + elif case_selector == henry: + return ifcdimensionalexponents(2,1,-2,-2,0,0,0) + elif case_selector == degree_celsius: + return ifcdimensionalexponents(0,0,0,0,1,0,0) + elif case_selector == lumen: + return ifcdimensionalexponents(0,0,0,0,0,0,1) + elif case_selector == lux: + return ifcdimensionalexponents(-2,0,0,0,0,0,1) + elif case_selector == becquerel: + return ifcdimensionalexponents(0,0,-1,0,0,0,0) + elif case_selector == gray: + return ifcdimensionalexponents(2,0,-2,0,0,0,0) + elif case_selector == sievert: + return ifcdimensionalexponents(2,0,-2,0,0,0,0) + else: + return ifcdimensionalexponents(0,0,0,0,0,0,0) + +#################### + # FUNCTION ifcmlstotalthickness # +#################### +def ifcmlstotalthickness(layerset,): + ''' + :param layerset + :type layerset:ifcmateriallayerset + ''' + if (SIZEOF(layerset.materiallayers) > 1): + for i in range(2,HIINDEX(layerset.materiallayers),1): + max = max + layerset.materiallayers[i].layerthickness + return max + +#################### + # FUNCTION ifccorrectobjectassignment # +#################### +def ifccorrectobjectassignment(constraint,objects,): + ''' + :param constraint + :type constraint:ifcobjecttypeenum + :param objects + :type objects:(null) + ''' + if ( not EXISTS(constraint)): + return TRUE + case_selector = constraint + if case_selector == ifcobjecttypeenum.notdefined: + return TRUE + elif case_selector == ifcobjecttypeenum.product: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.process: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.control: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.resource: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.actor: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.group: + # begin/end block + count = SIZEOF(None) + return count == 0 + elif case_selector == ifcobjecttypeenum.project: + # begin/end block + count = SIZEOF(None) + return count == 0 + else: + return None + +#################### + # FUNCTION ifccurveweightspositive # +#################### +def ifccurveweightspositive(b,): + ''' + :param b + :type b:ifcrationalbsplinecurvewithknots + ''' + for i in range(0,b.upperindexoncontrolpoints,1): + if (b.weights[i] <= 0): + result = FALSE + return result + return result + +#################### + # FUNCTION ifcsameaxis2placement # +#################### +def ifcsameaxis2placement(ap1,ap2,epsilon,): + ''' + :param ap1 + :type ap1:ifcaxis2placement + :param ap2 + :type ap2:ifcaxis2placement + :param epsilon + :type epsilon:REAL + ''' + return (ifcsamedirection(ap1.p[1],ap2.p[1],epsilon) and ifcsamedirection(ap1.p[2],ap2.p[2],epsilon)) and ifcsamecartesianpoint(ap1.location,ap1.location,epsilon) + +#################### + # FUNCTION ifcbuild2axes # +#################### +def ifcbuild2axes(refdirection,): + ''' + :param refdirection + :type refdirection:ifcdirection + ''' + return [d,ifcorthogonalcomplement(d)] + +#################### + # FUNCTION ifcconstraintsparambspline # +#################### +def ifcconstraintsparambspline(degree,upknots,upcp,knotmult,knots,): + ''' + :param degree + :type degree:INTEGER + :param upknots + :type upknots:INTEGER + :param upcp + :type upcp:INTEGER + :param knotmult + :type knotmult:(null) + :param knots + :type knots:(null) + ''' + sum = knotmult[1] + for i in range(2,upknots,1): + sum = sum + knotmult[i] + if ((((degree < 1) or (upknots < 2)) or (upcp < degree)) or (sum != ((degree + upcp) + 2))): + result = FALSE + return result + k = knotmult[1] + if ((k < 1) or (k > (degree + 1))): + result = FALSE + return result + for i in range(2,upknots,1): + if ((knotmult[i] < 1) or (knots[i] <= knots[i - 1])): + result = FALSE + return result + k = knotmult[i] + if ((i < upknots) and (k > degree)): + result = FALSE + return result + if ((i == upknots) and (k > (degree + 1))): + result = FALSE + return result + return result + +#################### + # FUNCTION ifccrossproduct # +#################### +def ifccrossproduct(arg1,arg2,): + ''' + :param arg1 + :type arg1:ifcdirection + :param arg2 + :type arg2:ifcdirection + ''' + if ((( not EXISTS(arg1)) or (arg1.dim == 2)) or (( not EXISTS(arg2)) or (arg2.dim == 2))): + return None + else: + # begin/end block + v1 = ifcnormalise(arg1).ifcdirection.directionratios + v2 = ifcnormalise(arg2).ifcdirection.directionratios + res = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcdirection([(v1[2] * v2[3]) - (v1[3] * v2[2]),(v1[3] * v2[1]) - (v1[1] * v2[3]),(v1[1] * v2[2]) - (v1[2] * v2[1])]) + mag = 0 + for i in range(1,3,1): + mag = mag + (res.directionratios[i] * res.directionratios[i]) + if (mag > 0): + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(res,SQRT(mag)) + else: + result = (ifcrepresentationitem() == ifcgeometricrepresentationitem()) == ifcvector(arg1,0) + return result + +#################### + # FUNCTION ifcsurfaceweightspositive # +#################### +def ifcsurfaceweightspositive(b,): + ''' + :param b + :type b:ifcrationalbsplinesurfacewithknots + ''' + for i in range(0,b.ifcbsplinesurface.uupper,1): + for j in range(0,b.ifcbsplinesurface.vupper,1): + if (b.weights[i][j] <= 0): + result = FALSE + return result + return result + +#################### + # FUNCTION ifcsamecartesianpoint # +#################### +def ifcsamecartesianpoint(cp1,cp2,epsilon,): + ''' + :param cp1 + :type cp1:ifccartesianpoint + :param cp2 + :type cp2:ifccartesianpoint + :param epsilon + :type epsilon:REAL + ''' + if (SIZEOF(cp1.coordinates) > 2): + cp1z = cp1.coordinates[3] + if (SIZEOF(cp2.coordinates) > 2): + cp2z = cp2.coordinates[3] + return (ifcsamevalue(cp1x,cp2x,epsilon) and ifcsamevalue(cp1y,cp2y,epsilon)) and ifcsamevalue(cp1z,cp2z,epsilon) + +#################### + # RULE ifcsingleprojectinstance # +#################### +ifcsingleprojectinstance = Rule() + +#################### + # RULE ifcrepresentationcontextsamewcs # +#################### +ifcrepresentationcontextsamewcs = Rule() diff --git a/src/Mod/Material/CMakeLists.txt b/src/Mod/Material/CMakeLists.txt index b5eae0429..707b97723 100644 --- a/src/Mod/Material/CMakeLists.txt +++ b/src/Mod/Material/CMakeLists.txt @@ -25,8 +25,12 @@ ADD_CUSTOM_TARGET(Material ALL SOURCES ${all_files} ) -fc_copy_sources(Material "${CMAKE_BINARY_DIR}/Mod/Material" ${all_files}) +#fc_copy_sources(Material "${CMAKE_BINARY_DIR}/Mod/Material" ${Material_SRCS}) +fc_target_copy_resource(Material + ${CMAKE_SOURCE_DIR}/src/Mod/Material + ${CMAKE_BINARY_DIR}/Mod/Material + ${Material_SRCS}) fc_target_copy_resource(Material ${CMAKE_SOURCE_DIR}/src/Mod/Material