POSC Specifications: Epicentre Version 3.0 | Logical Data Model |
Apply additional EPSG recomendations.
CHANGE ERP2_EPSG_coordinate_system (*<REMARK>CHANGE ERP2_EPSG_coordinate_system*) (*<DESC> Eliminate the concept of "applied" transformation because most transformations are specific to two systems. The exception is for some projected transformations which can be applied to several systems. Add subtypes of Coordinate_transformation to handle the distinctions of "concatenated", "map projection" and "everything else". The relationships from applied transformation to Face and Edge were not "moved" because no one knows what they are used for. If they are added back then they should probably be added to "value" so that they can represent a "parameter". *) (*<DESC> The uniqueness of the map projection is the inherited identifier. The uniqueness of both the concatenated and the geodetic transformations has been changed to use the target and source relationships. Requiring uniqueness on a string for transformations of local coordinate systems would require far more than 80 characters. Add Geodetic_coordinate_system as a subtype of Coordinate_system and a uniqueness rule on identifier. This will be the abstract supertype of all Earth systems and will allow their identifiers to be unique within the context of all Earth systems. Add a one-to-one relationship between geographic 2D and 3D systems and make it mandatory on the 3D side. We can then put the "standard" name on the 2D system and easily find the associated 3D system (if it exists). *) (*<DESC> Compound_coordinate_system inherits transformation relationships so a rule was added to insure that they are never populated. It was too messy to "model" this constraint. Coordinate_transformation_parameter was renamed to Coordinate_transformation_param_usage to better understand that the actual parameter is in Ref_coordinate_transformation_parameter. An optional relationship was added from transformation value to prime meridian. Add an optional relationship from axis to one unit of measure. Drop the relationship from the geodetic 2d/3d CS to prime meridian. Move it to Geodetic datum instead. This will allow us to be compatible with ISO. Remove Datum as a subtype of Earth_feature since it should NOT be represented by a Spatial_object. *) ALTER ENTITY datum DROP SUBTYPE OF (Earth_feature) ADD SUBTYPE OF (aliasable_technical_reference); END_ENTITY; DROP ENTITY applied_coordinate_transformation (*<CHANGE>This concept has been eliminated.*); ALTER ENTITY edge; INVERSE DROP applied_coordinate_transformation (*<CHANGE>Not needed.*); END_ENTITY; ALTER ENTITY face; INVERSE DROP applied_coordinate_transformation (*<CHANGE>Not needed.*); END_ENTITY; ALTER ENTITY coordinate_transformation ADD ABSTRACT; (*<DESC>The abstract supertype of all variations of transforming one coordinate system into another coordinate system.*) DROP coordinate_transformation_method (*<CHANGE>Moved to Single_transformation.*); INVERSE DROP applied_transformation (*<CHANGE>Dropped the concept.*); DROP coordinate_transformation_value (*<CHANGE>Moved to Single_transformation.*); END_ENTITY; ALTER ENTITY applied_concatenated_transformation AS concatenated_transformation ADD SUBTYPE OF (coordinate_transformation); (*<DESC>A transformation which is represented by an ordered list of single transformations.*) ADD source_coordinate_system : coordinate_system (*<DESC>This designates the coordinate system which is the source for the coordinate transformation. When transforming from one system to a another system, this points to the "from" system.*) (*<VERB>be based upon*); ADD target_coordinate_system : coordinate_system (*<DESC>This designates the coordinate system which is the target for the coordinate transformation. When transforming from one system to a another system, this points to the "to" system.*) (*<VERB>provide a result for*); INVERSE ALTER simple_transformation AS transformation_path; UNIQUE ADD si : source_coordinate_system, target_coordinate_system; WHERE ALTER val : EXISTS(transformation_path); (*<DESC>For each instance of concatenated transformation, the transformation path must be specified.*) ADD dri : target_coordinate_system :<>: source_coordinate_system (*<DESC>Each transformation must provide a result for a different coordinate system than the one it is based upon.*); END_ENTITY; ADD ENTITY single_transformation ABSTRACT SUPERTYPE OF (ONEOF(map_projection, geodetic_transformation)) SUBTYPE OF (coordinate_transformation); (*<DESC>An identified method and set of parameter values used to convert from one coordinate system to another coordinate system.*) (*<CHANGE>This entity represents the majority of the old semantics of Coordinate_transformation.*) coordinate_transformation_method : coordinate_transformation_method (*<DESC>This is the method used to define the coordinate transformation. The method describes the parameters to be used and the manner in which they are used.*) (*<VERB>be defined by*); INVERSE coordinate_transformation_value : SET [0:?] OF coordinate_transformation_value FOR single_transformation (*<DESC>These are the values of the coordinate transformation parameters that are defined for the coordinate transformation method that defines this coordinate transformation.*) (*<VERB>have*); END_ENTITY; ALTER ENTITY applied_simple_transformation AS geodetic_transformation ADD SUBTYPE OF (single_transformation); (*<DESC>This represents all non-projected transformations.*) ADD source_coordinate_system : coordinate_system (*<DESC>This designates the coordinate system which is the source for the coordinate transformation. For example, when transforming from a geocentric system to a geographic system, this points to the geocentric system.*) (*<VERB>be based upon*); ADD target_coordinate_system : coordinate_system (*<DESC>This designates the coordinate system which is the target for the coordinate transformation. For example, when transforming from a geocentric system to a geographic system, this points to the geographic system.*) (*<VERB>provide a result for*); DROP coordinate_transformation; INVERSE ALTER concatenated_transformation AS transformation_path (*<DESC>These are the concatenated transformations which utilize this transformation.*); UNIQUE ADD si : source_coordinate_system, target_coordinate_system; WHERE ADD dri : target_coordinate_system :<>: source_coordinate_system (*<DESC>Each transformation must provide a result for a different coordinate system than the one it is based upon.*); END_ENTITY; ADD ENTITY map_projection SUBTYPE OF (single_transformation); (*<DESC>This is a scheme for projecting a curved 2D geographic surface on a plane surface.*) INVERSE projected_2d_coordinate_system : SET[0:?] OF projected_2d_coordinate_system FOR map_projection (*<DESC>These are the projected coordinate systems which have been created by applying this map projection to a 2d geographic system.*) (*<VERB>be used in the creation of*); UNIQUE si : identifier; END_ENTITY; ALTER ENTITY coordinate_transformation_concatenation AS coordinate_transformation_path; (*<DESC>This association asserts that a geodetic transformation is utilized by a concatenated transformation.*) ALTER concatenated_transformation (*<DESC>This is the concatenated transformation which is composed of the geodetic transformation.*); ALTER simple_transformation AS geodetic_transformation (*<DESC>This is the geodetic transformation which is part of the concatenated transformation.*); ALTER apply_order (*<DESC>This is the order of application of the geodetic transformation within the context of the concatenated transformation. The first geodetic transformation should have a value of one.*); END_ENTITY; ALTER ENTITY coordinate_transformation_value; ALTER coordinate_transformation AS single_transformation ALTER TYPE AS single_transformation (*<DESC>This is the transformation for which this value of a transformation parameter is defined.*); ALTER coordinate_transformation_parameter AS coordinate_transformation_param_usage; ALTER vertex AS vertex_value; ADD prime_meridian_value : OPTIONAL prime_meridian (*<DESC>A prime meridian whose greenwich longitude is used as a coordinate transformation value.*) (*<VERB>use*); WHERE ADD sri : single_transformation.coordinate_transformation_method :=: coordinate_transformation_param_usage.coordinate_transformation_method (*<DESC>The method used by the associated transformation must be the same method which is represented by the associated parameter usage.*) (*<RULETYPE>SRI*); ALTER val1 : EXISTS(integer_value) XOR (EXISTS(location_value) XOR (EXISTS(quantity_value) XOR (EXISTS(vertex_value) XOR (EXISTS(prime_meridian_value) XOR (EXISTS(real_value) XOR EXISTS(string_value) ))))) (*<DESC>Each COORDINATE TRANSFORMATION VALUE must be instantiated with any one of INTEGER VALUE, LOCATION VALUE, QUANTITY VALUE, REAL VALUE, VERTEX VALUE, PRIME MMERIDIAN VALUE or STRING VALUE.*); END_ENTITY; ALTER ENTITY prime_meridian; INVERSE ADD coordinate_transformation_value : SET[0:?] OF coordinate_transformation_value FOR prime_meridian_value (*<DESC>These are the transformation values which use this prime meridian as the value.*) (*<VERB>be used by*); END_ENTITY; ALTER ENTITY coordinate_transformation_method; INVERSE ALTER coordinate_transformation AS single_transformation ALTER TYPE AS single_transformation (*<DESC>These are the transformations that use this method.*); ALTER coordinate_transformation_parameter AS coordinate_transformation_param_usage (*<DESC>This indicates the set of parameters that are defined for use by this coordinate transformation method.*); END_ENTITY; ALTER ENTITY coordinate_transformation_parameter AS coordinate_transformation_param_usage; END_ENTITY; ALTER ENTITY coordinate_system; INVERSE ALTER target_for AS target_for_geodetic ALTER TYPE AS geodetic_transformation (*<DESC>This describes the set of geodetic transformations that utilize this coordinate system as a target.*); ALTER source_for AS source_for_geodetic ALTER TYPE AS geodetic_transformation (*<DESC>This describes the set of geodetic transformations that utilize this coordinate system as a source.*); ADD target_for_concatenated : SET[0:?] OF concatenated_transformation FOR target_coordinate_system (*<DESC>This describes the set of concatenated transformations that utilize this coordinate system as a target.*) (*<VERB>be a target for*); ADD source_for_concatenated : SET[0:?] OF concatenated_transformation FOR source_coordinate_system (*<DESC>This describes the set of concatenated transformations that utilize this coordinate system as a source.*) (*<VERB>be a source for*); END_ENTITY; ADD ENTITY geodetic_coordinate_system ABSTRACT SUPERTYPE OF (ONEOF( geocentric_coordinate_system, geographic_2d_coordinate_system, projected_2d_coordinate_system, compound_coordinate_system, vertical_coordinate_system, geographic_3d_coordinate_system)) SUBTYPE OF (coordinate_system); (*<DESC>The abstract supertype of all coordinate systems whose context is the Earth.*) UNIQUE si : identifier; END_ENTITY; ALTER ENTITY geocentric_coordinate_system DROP SUBTYPE OF (coordinate_system); UNIQUE DROP SI; WHERE ADD val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.ref_axis_type) (*<DESC>For each instance, the number of axes must match the number allowed by the coordinate system constraint.*) (*<RULETYPE>VAL*); ADD val1 : SIZEOF(coordinate_system_axis) = 3 (*<DESC>For each instance, the number of axes must be three.*) (*<RULETYPE>VAL*); ADD val2 : (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 1) )) = 1) AND (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 2) )) = 1) AND (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 3) )) = 1) (*<DESC>For each instance, the axes must be defined with an order of 1, 2 and 3.*) (*<RULETYPE>VAL*); END_ENTITY; ALTER ENTITY projected_2d_coordinate_system DROP SUBTYPE OF (coordinate_system); ADD map_projection : map_projection (*<DESC>This is the map projection which was used to create this projected coordinate system.*) (*<VERB>be created using*); UNIQUE DROP SI; WHERE ADD val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.ref_axis_type) (*<DESC>For each instance, the number of axes must match the number allowed by the coordinate system constraint.*) (*<RULETYPE>VAL*); ADD val1 : SIZEOF(coordinate_system_axis) = 2 (*<DESC>For each instance, the number of axes must be two.*) (*<RULETYPE>VAL*); ADD val2 : (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 1) )) = 1) AND (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 2) )) = 1) (*<DESC>For each instance, the axes must be defined with an order of 1 and 2.*) (*<RULETYPE>VAL*); END_ENTITY; ALTER ENTITY compound_coordinate_system DROP SUBTYPE OF (coordinate_system); UNIQUE DROP SI; WHERE ADD 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.ref_axis_type) (*<DESC>For each instance, the cumulative number of axes in the component systems must match the number allowed by the coordinate system constraint.*) (*<RULETYPE>VAL*); ADD val1 : NOT EXISTS (coordinate_system_axis) (*<DESC>A Compound coordinate system cannot have its own axes.*) (*<RULETYPE>VAL*); ADD val2 : NOT EXISTS (target_for_geodetic) AND NOT EXISTS(source_for_geodetic) AND NOT EXISTS (target_for_concatenated) AND NOT EXISTS (source_for_concatenated) (*<DESC>Compound coordinate system cannot be transformed. Only the component systems can be transformed.*) (*<RULETYPE>VAL*); END_ENTITY; ALTER ENTITY vertical_coordinate_system DROP SUBTYPE OF (coordinate_system); UNIQUE DROP SI; WHERE ADD val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.ref_axis_type) (*<DESC>For each instance, the number of axes must match the number allowed by the coordinate system constraint.*) (*<RULETYPE>VAL*); ADD val1 : SIZEOF(coordinate_system_axis) = 1 (*<DESC>For each instance, the number of axes must be one.*) (*<RULETYPE>VAL*); ADD val2 : (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 1) )) = 1) (*<DESC>For each instance, the axis must be defined with an order of 1.*) (*<RULETYPE>VAL*); END_ENTITY; ALTER ENTITY geographic_2d_coordinate_system DROP SUBTYPE OF (coordinate_system); DROP prime_meridian (*<CHANGE>Moved to Geodetic_datum.*); INVERSE ADD geographic_3d_coordinate_system : SET[0:1] OF geographic_3d_coordinate_system FOR geographic_2d_coordinate_system (*<DESC>This is the 2D geographic which was derived from this system by dropping the vertical axis.*) (*<VERB>be derived from*); UNIQUE DROP SI; WHERE ADD val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.ref_axis_type) (*<DESC>For each instance, the number of axes must match the number allowed by the coordinate system constraint.*) (*<RULETYPE>VAL*); ADD val1 : SIZEOF(coordinate_system_axis) = 2 (*<DESC>For each instance, the number of axes must be three.*) (*<RULETYPE>VAL*); ADD val2 : (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 1) )) = 1) AND (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 2) )) = 1) (*<DESC>For each instance, the axes must be defined with an order of 1 and 2.*) (*<RULETYPE>VAL*); END_ENTITY; ALTER ENTITY geographic_3d_coordinate_system DROP SUBTYPE OF (coordinate_system); DROP prime_meridian (*<CHANGE>Moved to Geodetic_datum.*); ADD geographic_2d_coordinate_system : geographic_2d_coordinate_system (*<DESC>This is the 2D geographic which was derived from this system by dropping the vertical axis. The standard identifiers for geographic systems should be loaded in the 2d system with the inverse of this relationship used to locate the related 3d system.*) (*<VERB>be the source for*); UNIQUE DROP SI; WHERE ADD val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.ref_axis_type) (*<DESC>For each instance, the number of axes must match the number allowed by the coordinate system constraint.*) (*<RULETYPE>VAL*); ADD val1 : SIZEOF(coordinate_system_axis) = 3 (*<DESC>For each instance, the number of axes must be three.*) (*<RULETYPE>VAL*); ADD val2 : (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 1) )) = 1) AND (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 2) )) = 1) AND (SIZEOF(QUERY ( csa <* coordinate_system_axis | (csa.axis_order = 3) )) = 1) (*<DESC>For each instance, the axes must be defined with an order of 1, 2 and 3.*) (*<RULETYPE>VAL*); END_ENTITY; ALTER ENTITY local_coordinate_system; WHERE ADD val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.ref_axis_type) (*<DESC>For each instance, the number of axes must match the number allowed by the coordinate system constraint.*) (*<RULETYPE>VAL*); END_ENTITY; ALTER ENTITY nonspatial_coordinate_system; WHERE ADD val : SIZEOF(coordinate_system_axis) = SIZEOF(ref_coordinate_sys_constraint.ref_axis_type) (*<DESC>For each instance, the number of axes must match the number allowed by the coordinate system constraint.*) (*<RULETYPE>VAL*); END_ENTITY; ALTER ENTITY geodetic_datum; ADD prime_meridian : OPTIONAL prime_meridian (*<DESC>This is the prime meridian for the associated geographic coordinate systems.*) (*<VERB>be based upon*); UNIQUE ALTER si ADD prime_meridian LAST; END_ENTITY; ALTER ENTITY prime_meridian; INVERSE DROP geographic_3d; ALTER geographic_2d AS geodetic_datum ALTER TYPE AS geodetic_datum (*<DESC>These are the geodetic datums that use this prime meridian.*) (*<VERB>be used to define*); END_ENTITY; ALTER ENTITY coordinate_system_axis; ADD constrained_to_unit : OPTIONAL ref_unit_of_measure (*<DESC>This asserts that an axis is constrained to one unit of measure. Note that this is redundant to the constraints on ref_quantity_type.*) (*<VERB>be constrained to*); END_ENTITY; ALTER ENTITY ref_unit_of_measure; INVERSE ADD coordinate_system_axis : SET[0:?] OF coordinate_system_axis FOR constrained_to_unit (*<DESC>This is the set of coordinate system axes which are constrained to use this unit of measure.*) (*<VERB>constrain*); END_ENTITY; END_CHANGE;