POSC Specifications: Epicentre Version 3.0 | Logical Data Model |
This change reworks the ref property type/kind part of the model as shown on diagram 'MTP: Reference Properties'. The purpose is to simplify the type/kind specification and to add the capability of capturing the information which is contained in the NDT specifications. The kind of property will be independent of any possible representations. Replace many-to-many relationships with intersection entity. Add an optional mechanism to specialize/classify kinds.
CHANGE ERP2_property_type (*<REMARK> CHANGE ERP2_property_type *) (*<DESC> This change reworks the ref property type/kind part of the model as shown on diagram 'MTP: Reference Properties'. The purpose is to simplify the type/kind specification and to add the capability of capturing the information which is contained in the NDT specifications. The kind of property will be independent of any possible representations. Replace many-to-many relationships with intersection entity. Add an optional mechanism to specialize/classify kinds. *) DROP ENTITY ref_kind_descriptor (*<CHANGE>Move to property_class.*); DROP ENTITY ref_property_qualifier (*<CHANGE>Move to property_class.*); DROP ENTITY ref_property_kind (*<CHANGE>Move semantics to property_kind.*); DROP ENTITY ref_descriptive_property (*<CHANGE>Move semantics to property_kind.*); DROP ENTITY ref_property_type (*<CHANGE>Move semantics to property_kind.*); ALTER ENTITY ref_quantity_property AS property_kind ADD SUBTYPE OF (aliasable_technical_reference); (*<DESC>The type or kind of property. Each kind of property may be realized using any representation type (e.g., string, quantity, logical, etc). For each kind of property, a constraint may be defined for different representations.*) ADD parent_kind : OPTIONAL property_kind (*<DESC>The more general property of which this property is a specialization. The semantics of a child property must be a subset of the semantics of the parent property. That is, the child property must represent a specialization of the parent concept by narrowing the meaning of the parent concept.*) (*<VERB>be a specialization of *); ALTER ref_quantity_type AS quantity_constraint ADD OPTIONAL (*<DESC>Specifies the required quantity type of this property if it is instantiated as a quantity. This is semantically equivalent to the quantity type on a QUANTITY data type specification.*) (*<VERB>have quantity constrained to*); ADD money_constraint : OPTIONAL ref_currency_unit (*<DESC>Specifies the required currency unit of this property if it is instantiated as a quantity. This is semantically equivalent to the currency type on a MONEY data type specification. If not specified then there is no constraint on the currency unit.*) (*<VERB>have money constrained to*); ADD geometry_constraint : OPTIONAL ref_coordinate_sys_constraint (*<DESC>Specifies the required coordinate system constraint of this property if it is instantiated as a geometry. This is semantically equivalent to the constraint type on a LOCATION, LINE, SURFACE, VOLUME or POINT data type specification. If not specified then there is no constraint on the coordinate system.*) (*<VERB>have geometry constrained to*); ADD property_constraint : OPTIONAL ref_property_set (*<DESC>Specifies the required property set of this property if it is instantiated as a geometry. Any instantiated properties must be selected from this set. This is semantically equivalent to the constraint type on a POINT, ELEMENT or SAMPLE data type specification. If not specified then there is no constraint on the properties.*) (*<VERB>have property constrained to*); ADD enumeration_constraint : OPTIONAL naming_system (*<DESC>Specifies the required coordinate system constraint of this property if it is instantiated as a generic enumeration. Any enumeration values must be selected from this naming system. If not specified then there is no constraint on the naming system.*) (*<VERB>have enumeration constrained to*); ADD ndt_data_type : OPTIONAL ndt_data_type (*<DESC>If this property kind was specified in a named defined type (ndt) specification then this is the data type that was declared in that specification.*); ADD fixed_length : OPTIONAL ndt_boolean (*<DESC>If the data type is a STRING then TRUE indicates that it should be a FIXED length string.*); ADD element_type : OPTIONAL ndt_element_type (*<DESC>If the data type is an ELEMENT then it is constrained to this element type. If not specified then there is no constraint on the element type.*); ADD surface_type : OPTIONAL ndt_surface_type (*<DESC>If the data type is a SURFACE then it is constrained to this surface type. If not specified then there is no constraint on the surface type.*); ADD grid_type : OPTIONAL ndt_grid_type (*<DESC>If the data type is an ELEMENT then it is constrained to this grid type. If not specified then there is no constraint on the grid type.*); ADD data_precision : OPTIONAL ndt_pint4 (*<DESC>This is the minimum precision which must be maintained in the data. If not specified then there is no constraint on the precision.*); ADD string_length : OPTIONAL ndt_pint4 (*<DESC>If the data type is a STRING then this it is constrained to this maximum string length. If not specified then there is no constraint on the string length.*); ADD max_value : OPTIONAL ndt_real4 (*<DESC>If the data type is an INTEGER or REAL then it is constrained to this maximum value. If not specified then there is no constraint on the value.*); ADD min_value : OPTIONAL ndt_real4 (*<DESC>If the data type is an INTEGER or REAL then it is constrained to this minimum value. If not specified then there is no constraint on the value.*); INVERSE ADD representation_type : SET[0:?] OF representation_type FOR property_kind (*<DESC>These are the allowed representation types for this property kind. If none are specified then all types are allowed.*) (*<VERB>be constrained to*); ADD child_kind : SET[0:?] OF property_kind FOR parent_kind (*<DESC>The set of property kinds for which this kind is a generalization.*) (*<VERB>be the generalization of*); ADD property_classification : SET[0:?] OF property_classification FOR property_kind (*<DESC>These are the classifications which characterize this property kind.*) (*<VERB>be characterized by*); UNIQUE ADD si : identifier; END_ENTITY; ALTER ENTITY coordinate_system_axis; ALTER ref_quantity_property AS property_kind (*<VERB>represent*); END_ENTITY; ALTER ENTITY ref_quantity_type; INVERSE ALTER ref_quantity_property AS property_constraint (*<DESC>These are the property kinds which are constrained to this property type if they are instantiated using a QUANTITY data type.*) (*<VERB>constrain*); END_ENTITY; ALTER ENTITY ref_currency_unit; INVERSE ADD property_kind : SET[0:?] OF property_kind FOR money_constraint (*<DESC>These are the property kinds which are constrained to use this unit if instantiated using MONEY a data type.*) (*<VERB>constrain*); END_ENTITY; ALTER ENTITY ref_coordinate_sys_constraint; INVERSE ADD property_kind : SET[0:?] OF property_kind FOR geometry_constraint (*<DESC>These are the property kinds which are constrained to use this coordinate system constraint if instantiated using a LOCATION, LINE, SURFACE, VOLUME or POINT data type.*) (*<VERB>constrain*); END_ENTITY; ALTER ENTITY ref_property_set; INVERSE ADD constrained_kind : SET[0:?] OF property_kind FOR property_constraint (*<DESC>These are the property kinds which are constrained to use this property set if instantiated using a POINT, ELEMENT or SAMPLE data type.*) (*<VERB>constrain*); END_ENTITY; ALTER ENTITY naming_system; INVERSE ADD property_kind : SET[0:?] OF property_kind FOR enumeration_constraint (*<DESC>These are the property kinds which are constrained to use a value from this naming system if instantiated using a generic enumeration.*) (*<VERB>constrain*); END_ENTITY; ADD ENTITY representation_type (*<DESC>This specifies a type of representation that a property kind is allowed to use.*); property_kind : property_kind (*<DESC>This is the property kind which is allowed to use the data type.*) (*<VERB>be a constraint for*); data_type : ndt_data_type (*<DESC>This is the data type of the allowed representation.*); UNIQUE si : property_kind, data_type; END_ENTITY; ADD TYPE ndt_data_type = ENUMERATION OF ( integer_type, binary_type, logical_type, boolean_type, string_type, real_type, enumeration_type, ratio_type, money_type, rational_type, angle_type, daytimeinterval_type, date_type, timestamp_type, time_type, sample_type, point_type, element_type, volume_type, surface_type, line_type, location_type, quantity_type, unstructured_3d_topology_type ) (*<DESC>These are the allowed data types for a generic property. The list includes all EXPRESS simple types and all Epicentre extended types.*); END_TYPE; ADD TYPE ndt_grid_type = ENUMERATION OF ( trimesh_type, grid_type, grid1d_type, grid2d_type, grid3d_type, grid4d_type, grid5d_type, grid6d_type, grid7d_type, grid8d_type, grid9d_type, grid10d_type, grid11d_type, grid12d_type, grid13d_type, grid14d_type, grid15d_type, grid16d_type ) (*<DESC>These are the allowed grid types for an ELEMENT data type.*); END_TYPE; ADD TYPE ndt_element_type = ENUMERATION OF ( node_type, edge_type, face_type, cell_type ) (*<DESC>These are the allowed element types for an ELEMENT data type.*); END_TYPE; ADD TYPE ndt_surface_type = ENUMERATION OF ( trimesh_type, grid_type, contour_type ) (*<DESC>These are the allowed representation types for a SURFACE data type.*); END_TYPE; ----------- Move existing relationships to property_kind. ALTER ENTITY property_kind; INVERSE ADD common_activity_property : SET[0:?] OF common_activity_property FOR property_kind (*<DESC>The set of associations which assert that this kind of property is commonly associated with members of a class.*) (*<VERB> be common to*); ADD common_data_trace_property : SET[0:?] OF common_data_trace_property FOR property_kind (*<DESC>The set of associations which assert that this kind of property is commonly associated with members of a class.*) (*<VERB> be common to*); ADD common_facility_property : SET[0:?] OF common_facility_property FOR property_kind (*<DESC>The set of associations which assert that this kind of property is commonly associated with members of a class.*) (*<VERB> be common to*); ADD common_material_property : SET[0:?] OF common_material_property FOR property_kind (*<DESC>The set of associations which assert that this kind of property is commonly associated with members of a class.*) (*<VERB> be common to*); ADD isoline_set : SET[0:?] OF isoline_set FOR property_kind (*<DESC>The set of isoline sets which represent this property kind.*) (*<VERB>be represented by*); ADD pty_generic_property : SET[0:?] OF pty_generic_property FOR property_kind (*<DESC>The set of generic properties which represent this property kind.*) (*<VERB>be represented by*); ADD pty_descriptive_text : SET[0:?] OF pty_descriptive_text FOR kind (*<DESC>The set of descriptive text properties which represent this property kind.*) (*<VERB>be represented by*); ADD grid_1d_equal : SET[0:?] OF grid_1d_equal FOR property_kind (*<DESC>The set of descriptive text properties which represent this property kind.*) (*<VERB>be represented by*); END_ENTITY; ALTER ENTITY common_activity_property; ALTER property_kind ALTER TYPE AS property_kind; END_ENTITY; ALTER ENTITY common_material_property; ALTER property_kind ALTER TYPE AS property_kind; END_ENTITY; ALTER ENTITY common_data_trace_property; ALTER property_kind ALTER TYPE AS property_kind; END_ENTITY; ALTER ENTITY common_facility_property; ALTER property_kind ALTER TYPE AS property_kind; END_ENTITY; ALTER ENTITY common_material_property; ALTER property_kind ALTER TYPE AS property_kind; END_ENTITY; ALTER ENTITY isoline_set; ALTER ref_property_kind AS property_kind ALTER TYPE AS property_kind (*<VERB>represent*); END_ENTITY; ALTER ENTITY pty_generic_property; ALTER ref_property_kind AS property_kind ALTER TYPE AS property_kind; END_ENTITY; ALTER ENTITY pty_descriptive_text; ALTER kind ALTER TYPE AS property_kind (*<VERB>represent*); END_ENTITY; ALTER ENTITY grid_1d_equal; ALTER ref_quantity_property AS property_kind; END_ENTITY; ----------- classification ADD ENTITY property_classification SUBTYPE OF (association_reference) (*<DESC>An association indicating that an property kind is characterized as being a member of an property kind class. This asserts a conformance to the meaning of the class.*); property_kind : property_kind (*<DESC>This is the kind which is being characterized.*) (*<VERB>characterize*); property_class : property_class (*<DESC>This is the class that the kind conforms to.*) (*<VERB>be a member of*); UNIQUE si : property_kind, property_class; END_ENTITY; ADD ENTITY property_class SUBTYPE OF (classification_class) (*<DESC>A characterization of properties based a range of characteristics.*); parent_class : OPTIONAL property_class (*<DESC>The more general class of which this class is a specialization. The semantics of a child class must be a subset of the semantics of the parent class. That is, the child class must represent a specialization of the parent concept by narrowing the meaning of the parent concept. Conformance to a class where the meaning of the class is not altered should be handled by class classification instead of by parent/child. The naming system of the child class should either be the same as the naming system of the parent class or it should be a specialization of that naming system.*) (*<VERB>be a specialization of*); INVERSE property_classification : SET[0:?] OF property_classification FOR property_class (*<DESC>These are the classifications which are characterized by this class.*) (*<VERB>characterize*); child_class : SET[0:?] OF property_class FOR parent_class (*<DESC>The set of classes for which this class is a generalization.*) (*<VERB>be the generalization of*); classify : SET[0:?] OF property_class_classification FOR be_classified_as (*<DESC>Asserts that another class is a member of this class. The naming systems of the two classes should be different and one naming system should not be a specialization of the other.*) (*<VERB>classify*); be_a_member_of : SET[0:?] OF property_class_classification FOR have_as_a_member (*<DESC>Asserts that this class is a member of another class. The naming systems of the two classes should be different and one naming system should not be a specialization of the other.*) (*<VERB>be a member of*); UNIQUE si : identifier, naming_system; END_ENTITY; ADD ENTITY property_class_classification SUBTYPE OF (class_classification) (*<DESC>The specification of class relationships among property classes.*); be_classified_as : property_class (*<DESC>Specifies the general class in which specific classes are assigned.*) (*<VERB>be classified as*); have_as_a_member : property_class (*<DESC>Specifies the class which is a member of a general class. The member class conforms to the semantics of the general class.*) (*<VERB>have as a member*); UNIQUE si : be_classified_as, have_as_a_member; END_ENTITY; (*<REMARK>====ref_quantity_property >- be referenced by\have as alternatives -< ref_axis_type====*) ALTER ENTITY ref_axis_type; ALTER ref_quantity_property AS quantity_property INVERT ALTER TYPE AS axis_type_alternative ALTER FOR AS axis_type; WHERE ADD val : EXISTS(quantity_property) (*<DESC>Each instance must specify alternative quantity properties.*) (*<RULETYPE>val*); END_ENTITY; ALTER ENTITY ref_quantity_property; INVERSE ALTER ref_axis_type AS axis_type ALTER TYPE AS axis_type_alternative ALTER FOR AS property_kind (*<DESC>These are the axis types which specify this property as an alternative property of an axis.*) (*<VERB>be an alternative for*); UNIQUE ADD si : identifier; END_ENTITY; ADD ENTITY axis_type_alternative SUBTYPE OF (association_reference) (*<DESC>This association asserts that a property kind is an alternative property for a type of coordinate system axis.*) (*<CHANGE>Previously implemented as table R_QUANTITY_PTY_X.*); axis_type : ref_axis_type (*<DESC>This is the type of coordinate system axis which has specified the property kind as an alternative.*) (*<VERB>be an alternative for*); property_kind : property_kind (*<DESC>this is the property kind which is an alternative property for a coordinate system axis of the specified type.*) (*<VERB>have as an alternative*); UNIQUE si : axis_type, property_kind; END_ENTITY; (*<REMARK>====ref_property_type >- be referenced by\contain -< ref_property_set====*) ALTER ENTITY ref_property_set; ALTER ref_property_type AS component_kind ALTER INVERT ALTER TYPE AS property_set_composition ALTER FOR AS property_set (*<DESC>These are the property kinds that are members of the set.*); WHERE ADD val : EXISTS(component_kind) (*<DESC>Each instance must specify component kinds for the set.*) (*<RULETYPE>val*); END_ENTITY; ALTER ENTITY property_kind; INVERSE ADD property_set : SET[0:?] OF property_set_composition FOR property_kind (*<DESC>These are the property sets which include this kind.*) (*<VERB>be part of*); END_ENTITY; ADD ENTITY property_set_composition SUBTYPE OF (association_reference); (*<DESC>This association asserts that a property kind is part of a property set.*) (*<CHANGE>Previously implemented as table R_PROPERTY_TY_X.*) property_set: ref_property_set (*<DESC>This is the property set that includes the property kind.*) (*<VERB>be part of*); property_kind : property_kind (*<DESC>This is the property kind that is part of the property set.*) (*<VERB>contain*); UNIQUE si : property_set, property_kind; END_ENTITY; (*<REMARK>====ref_axis_type >- be referenced by\specify -< ref_coordinate_sys_constraint====*) ALTER ENTITY ref_coordinate_sys_constraint; ALTER ref_axis_type AS axis_type ALTER INVERT ALTER TYPE AS coordinate_axis_constraint ALTER FOR AS coordinate_system_constraint ALTER AGGREGATE AS SET; WHERE ADD val : EXISTS(axis_type) (*<DESC>Each constraint must specify axis types.*) (*<RULETYPE>val*); END_ENTITY; ALTER ENTITY ref_axis_type; INVERSE ALTER ref_coordinate_sys_constraint AS coordinate_system_constraint ALTER TYPE AS coordinate_axis_constraint ALTER FOR AS axis_type (*<DESC>These are the coordinate system constraints which specify this axis type.*) (*<VERB>be specified by*); END_ENTITY; ADD ENTITY coordinate_axis_constraint SUBTYPE OF (association_reference); (*<DESC>This association asserts that an axis type is part of a coordinate system constraint.*) (*<CHANGE>Previously implemented as table R_AXIS_TYPE_X.*) axis_type: ref_axis_type (*<DESC>This is an axis type which is part of the coordinate system constraint.*) (*<VERB>specify*); coordinate_system_constraint : ref_coordinate_sys_constraint (*<DESC>This is a coordinate system constraint that specifies the axis type.*) (*<VERB>be specified by*); axis_order : ndt_pint1 (*<DESC>This is the order of the axis type within the definition of the coordinate system constraint. The first type should have an order of one, the second type should have an order of two, etc.*); UNIQUE si : axis_type, coordinate_system_constraint; END_ENTITY; ALTER ENTITY geocentric_coordinate_system; WHERE ALTER val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.axis_type); END_ENTITY; ALTER ENTITY projected_2d_coordinate_system; WHERE ALTER val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.axis_type); END_ENTITY; ALTER ENTITY compound_coordinate_system; WHERE ALTER val : ( SIZEOF(geographic_system.coordinate_system_axis) + SIZEOF(local_system.coordinate_system_axis) + SIZEOF(projected_system.coordinate_system_axis) + SIZEOF(vertical_system.coordinate_system_axis) ) = SIZEOF(ref_coordinate_sys_constraint.axis_type); END_ENTITY; ALTER ENTITY vertical_coordinate_system; WHERE ALTER val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.axis_type); END_ENTITY; ALTER ENTITY geographic_2d_coordinate_system; WHERE ALTER val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.axis_type); END_ENTITY; ALTER ENTITY geographic_3d_coordinate_system; WHERE ALTER val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.axis_type); END_ENTITY; ALTER ENTITY local_coordinate_system; WHERE ALTER val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.axis_type); END_ENTITY; ALTER ENTITY nonspatial_coordinate_system; WHERE ALTER val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.axis_type); END_ENTITY; (*<REMARK>====ref_unit_of_measure >- be alternative unit for\have -< ref_quantity_type====*) ALTER ENTITY ref_quantity_type; ALTER alternative_unit_of_measure ALTER INVERT ALTER TYPE AS quantity_type_alternative ALTER FOR AS quantity_type; WHERE ADD val2 : EXISTS(alternative_unit_of_measure) (*<DESC>Each constraint must specify alternative units of measure.*) (*<RULETYPE>val*); END_ENTITY; ALTER ENTITY ref_unit_of_measure; INVERSE ALTER alternative_unit_for ALTER TYPE AS quantity_type_alternative ALTER FOR AS unit_of_measure; END_ENTITY; ADD ENTITY quantity_type_alternative SUBTYPE OF (association); (*<DESC>This association asserts that a unit of measure is an alternative unit for a quantity type.*) (*<CHANGE>Previously implemented as table ALT_UOM_X.*) unit_of_measure: ref_unit_of_measure (*<DESC>This is a unit of measure that is an alternative for the quantity type.*) (*<VERB>have*); quantity_type : ref_quantity_type (*<DESC>This is a quantity type which allows the unit of measure as an alternative.*) (*<VERB>be alternative unit for*); UNIQUE si : unit_of_measure, quantity_type; END_ENTITY; END_CHANGE;