(* AIM EXPRESS long form for ISO/CD 10303-219

2004-10-15

Len Slovensky

ISO TC184/SC4/WG3 N1517

*)

SCHEMA dimensional_inspection_schema;

CONSTANT

dummy_gri : geometric_representation_item := representation_item('') ||

geometric_representation_item();

dummy_tri : topological_representation_item := representation_item('')

|| topological_representation_item();

END_CONSTANT;

TYPE ahead_or_behind = ENUMERATION OF

(exact,

ahead,

behind);

END_TYPE; -- ahead_or_behind

TYPE amount_of_substance_measure = REAL;

END_TYPE; -- amount_of_substance_measure

TYPE angle_relator = ENUMERATION OF

(equal,

small,

large);

END_TYPE; -- angle_relator

TYPE area_measure = REAL;

END_TYPE; -- area_measure

TYPE attribute_type = SELECT

(label,

text);

END_TYPE; -- attribute_type

TYPE axis2_placement = SELECT

(axis2_placement_2d,

axis2_placement_3d);

END_TYPE; -- axis2_placement

TYPE b_spline_curve_form = ENUMERATION OF

(elliptic_arc,

polyline_form,

parabolic_arc,

circular_arc,

unspecified,

hyperbolic_arc);

END_TYPE; -- b_spline_curve_form

TYPE b_spline_surface_form = ENUMERATION OF

(surf_of_linear_extrusion,

plane_surf,

generalised_cone,

toroidal_surf,

conical_surf,

spherical_surf,

unspecified,

ruled_surf,

surf_of_revolution,

cylindrical_surf,

quadric_surf);

END_TYPE; -- b_spline_surface_form

TYPE boolean_operand = SELECT

(solid_model);

END_TYPE; -- boolean_operand

TYPE celsius_temperature_measure = REAL;

END_TYPE; -- celsius_temperature_measure

TYPE characterized_action_definition = SELECT

(action,

action_method);

END_TYPE; -- characterized_action_definition

TYPE characterized_definition = SELECT

(characterized_object,

characterized_product_definition,

shape_definition);

END_TYPE; -- characterized_definition

TYPE characterized_product_definition = SELECT

(product_definition);

END_TYPE; -- characterized_product_definition

TYPE characterized_resource_definition = SELECT

(action_resource,

action_resource_requirement);

END_TYPE; -- characterized_resource_definition

TYPE compound_item_definition = SELECT

(set_representation_item);

END_TYPE; -- compound_item_definition

TYPE count_measure = NUMBER;

END_TYPE; -- count_measure

TYPE curve_on_surface = SELECT

(pcurve,

surface_curve,

composite_curve_on_surface);

END_TYPE; -- curve_on_surface

TYPE date_item = SELECT

(dm_program_run);

END_TYPE; -- date_item

TYPE date_time_or_event_occurrence = SELECT

(date_time_select);

END_TYPE; -- date_time_or_event_occurrence

TYPE date_time_select = SELECT

(date,

local_time,

date_and_time);

END_TYPE; -- date_time_select

TYPE day_in_month_number = INTEGER;

WHERE

wr1: (1 <= SELF) AND (SELF <= 31);

END_TYPE; -- day_in_month_number

TYPE derived_property_select = SELECT

(property_definition,

action_property,

resource_property);

END_TYPE; -- derived_property_select

TYPE description_attribute_select = SELECT

(application_context,

date_role,

external_source,

organization_role,

person_and_organization_role,

person_and_organization,

property_definition_representation,

representation);

END_TYPE; -- description_attribute_select

TYPE dimension_count = INTEGER;

WHERE

wr1: SELF > 0;

END_TYPE; -- dimension_count

TYPE dimensional_characteristic = SELECT

(dimensional_location,

dimensional_size);

END_TYPE; -- dimensional_characteristic

TYPE document_reference_item = SELECT

(product_definition_formation,

externally_defined_feature_definition,

externally_defined_dimension_definition);

END_TYPE; -- document_reference_item

TYPE electric_current_measure = REAL;

END_TYPE; -- electric_current_measure

TYPE founded_item_select = SELECT

(founded_item,

representation_item);

END_TYPE; -- founded_item_select

TYPE geometric_set_select = SELECT

(point,

curve,

surface);

END_TYPE; -- geometric_set_select

TYPE hour_in_day = INTEGER;

WHERE

wr1: (0 <= SELF) AND (SELF < 24);

END_TYPE; -- hour_in_day

TYPE id_attribute_select = SELECT

(action,

address,

property_definition,

shape_aspect,

shape_aspect_relationship,

application_context,

organizational_project,

representation);

END_TYPE; -- id_attribute_select

TYPE identifier = STRING;

END_TYPE; -- identifier

TYPE knot_type = ENUMERATION OF

(uniform_knots,

quasi_uniform_knots,

piecewise_bezier_knots,

unspecified);

END_TYPE; -- knot_type

TYPE label = STRING;

END_TYPE; -- label

TYPE length_measure = REAL;

END_TYPE; -- length_measure

TYPE limit_condition = ENUMERATION OF

(regardless_of_feature_size,

maximum_material_condition,

least_material_condition);

END_TYPE; -- limit_condition

TYPE list_of_reversible_topology_item = LIST [0:?] OF

reversible_topology_item;

END_TYPE; -- list_of_reversible_topology_item

TYPE luminous_intensity_measure = REAL;

END_TYPE; -- luminous_intensity_measure

TYPE mass_measure = REAL;

END_TYPE; -- mass_measure

TYPE measure_value = SELECT

(length_measure,

mass_measure,

time_measure,

electric_current_measure,

thermodynamic_temperature_measure,

celsius_temperature_measure,

amount_of_substance_measure,

luminous_intensity_measure,

plane_angle_measure,

solid_angle_measure,

area_measure,

volume_measure,

ratio_measure,

parameter_value,

positive_length_measure,

positive_plane_angle_measure,

count_measure);

END_TYPE; -- measure_value

TYPE minute_in_hour = INTEGER;

WHERE

wr1: (0 <= SELF) AND (SELF <= 59);

END_TYPE; -- minute_in_hour

TYPE month_in_year_number = INTEGER;

WHERE

wr1: (1 <= SELF) AND (SELF <= 12);

END_TYPE; -- month_in_year_number

TYPE name_attribute_select = SELECT

(address,

derived_unit,

person_and_organization,

product_definition,

property_definition_representation);

END_TYPE; -- name_attribute_select

TYPE organization_item = SELECT

(dm_program_identification,

dm_program_run);

END_TYPE; -- organization_item

TYPE parameter_value = REAL;

END_TYPE; -- parameter_value

TYPE pcurve_or_surface = SELECT

(pcurve,

surface);

END_TYPE; -- pcurve_or_surface

TYPE person_and_organization_item = SELECT

(dm_program_identification,

dm_program_run);

END_TYPE; -- person_and_organization_item

TYPE person_organization_select = SELECT

(person,

organization,

person_and_organization);

END_TYPE; -- person_organization_select

TYPE plane_angle_measure = REAL;

END_TYPE; -- plane_angle_measure

TYPE positive_length_measure = length_measure;

WHERE

wr1: SELF > 0;

END_TYPE; -- positive_length_measure

TYPE positive_plane_angle_measure = plane_angle_measure;

WHERE

wr1: SELF > 0;

END_TYPE; -- positive_plane_angle_measure

TYPE preferred_surface_curve_representation = ENUMERATION OF

(pcurve_s2,

pcurve_s1,

curve_3d);

END_TYPE; -- preferred_surface_curve_representation

TYPE product_or_formation_or_definition = SELECT

(product,

product_definition_formation,

product_definition);

END_TYPE; -- product_or_formation_or_definition

TYPE property_or_shape_select = SELECT

(property_definition,

shape_definition);

END_TYPE; -- property_or_shape_select

TYPE ratio_measure = REAL;

END_TYPE; -- ratio_measure

TYPE represented_definition = SELECT

(property_definition,

property_definition_relationship,

shape_aspect,

shape_aspect_relationship);

END_TYPE; -- represented_definition

TYPE reversible_topology = SELECT

(reversible_topology_item,

list_of_reversible_topology_item,

set_of_reversible_topology_item);

END_TYPE; -- reversible_topology

TYPE reversible_topology_item = SELECT

(edge,

path,

face,

face_bound,

closed_shell,

open_shell);

END_TYPE; -- reversible_topology_item

TYPE role_select = SELECT

(document_reference,

security_classification_assignment);

END_TYPE; -- role_select

TYPE second_in_minute = REAL;

WHERE

wr1: (0 <= SELF) AND (SELF <= 60);

END_TYPE; -- second_in_minute

TYPE security_classification_item = SELECT

(product_definition_formation);

END_TYPE; -- security_classification_item

TYPE set_of_reversible_topology_item = SET [0:?] OF

reversible_topology_item;

END_TYPE; -- set_of_reversible_topology_item

TYPE set_representation_item = SET [1:?] OF representation_item;

END_TYPE; -- set_representation_item

TYPE shape_definition = SELECT

(product_definition_shape,

shape_aspect,

shape_aspect_relationship);

END_TYPE; -- shape_definition

TYPE shell = SELECT

(open_shell,

closed_shell);

END_TYPE; -- shell

TYPE si_prefix = ENUMERATION OF

(exa,

pico,

mega,

femto,

atto,

centi,

nano,

hecto,

micro,

tera,

giga,

milli,

peta,

deci,

kilo,

deca);

END_TYPE; -- si_prefix

TYPE si_unit_name = ENUMERATION OF

(hertz,

degree_celsius,

siemens,

sievert,

lux,

watt,

ohm,

second,

becquerel,

pascal,

henry,

tesla,

volt,

joule,

kelvin,

ampere,

gram,

steradian,

mole,

lumen,

gray,

candela,

farad,

radian,

newton,

metre,

weber,

coulomb);

END_TYPE; -- si_unit_name

TYPE solid_angle_measure = REAL;

END_TYPE; -- solid_angle_measure

TYPE source_item = SELECT

(identifier);

END_TYPE; -- source_item

TYPE supported_item = SELECT

(action,

action_method);

END_TYPE; -- supported_item

TYPE text = STRING;

END_TYPE; -- text

TYPE thermodynamic_temperature_measure = REAL;

END_TYPE; -- thermodynamic_temperature_measure

TYPE time_measure = REAL;

END_TYPE; -- time_measure

TYPE tolerance_method_definition = SELECT

(tolerance_value,

limits_and_fits);

END_TYPE; -- tolerance_method_definition

TYPE tolerance_select = SELECT

(geometric_tolerance,

plus_minus_tolerance);

END_TYPE; -- tolerance_select

TYPE transformation = SELECT

(functionally_defined_transformation);

END_TYPE; -- transformation

TYPE transition_code = ENUMERATION OF

(discontinuous,

cont_same_gradient_same_curvature,

cont_same_gradient,

continuous);

END_TYPE; -- transition_code

TYPE trimming_select = SELECT

(cartesian_point,

parameter_value);

END_TYPE; -- trimming_select

TYPE unit = SELECT

(named_unit,

derived_unit);

END_TYPE; -- unit

TYPE value_qualifier = SELECT

(precision_qualifier,

type_qualifier,

uncertainty_qualifier);

END_TYPE; -- value_qualifier

TYPE vector_or_direction = SELECT

(vector,

direction);

END_TYPE; -- vector_or_direction

TYPE volume_measure = REAL;

END_TYPE; -- volume_measure

TYPE year_number = INTEGER;

END_TYPE; -- year_number

ENTITY action;

name: label;

description : OPTIONAL text;

chosen_method : action_method;

DERIVE

id : identifier := get_id_value(SELF);

WHERE

wr1: SIZEOF(USEDIN(SELF,'DIMENSIONAL_INSPECTION_SCHEMA.' +

'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;

END_ENTITY; -- action

ENTITY action_method;

name : label;

description : OPTIONAL text;

consequence : text;

purpose : text;

END_ENTITY; -- action_method

ENTITY action_property;

name : label;

description : text;

definition : characterized_action_definition;

END_ENTITY; -- action_property

ENTITY action_property_representation;

name : label;

description : text;

property : action_property;

representation : representation;

END_ENTITY; -- action_property_representation

ENTITY action_resource;

name : label;

description : OPTIONAL text;

usage : SET [1:?] OF supported_item;

kind : action_resource_type;

END_ENTITY; -- action_resource

ENTITY action_resource_requirement;

name : label;

description : text;

kind : resource_requirement_type;

OPERATIONS : SET [1:?] OF characterized_action_definition;

END_ENTITY; -- action_resource_requirement

ENTITY action_resource_type;

name : label;

END_ENTITY; -- action_resource_type

ENTITY address;

internal_location : OPTIONAL label;

street_number : OPTIONAL label;

street : OPTIONAL label;

postal_box : OPTIONAL label;

town: OPTIONAL label;

region : OPTIONAL label;

postal_code : OPTIONAL label;

country : OPTIONAL label;

facsimile_number : OPTIONAL label;

telephone_number : OPTIONAL label;

electronic_mail_address : OPTIONAL label;

telex_number : OPTIONAL label;

DERIVE

name : label := get_name_value(SELF);

url : identifier := get_id_value(SELF);

WHERE

wr1: ((((((((((EXISTS(internal_location) OR EXISTS(street_number))

OR EXISTS(street)) OR EXISTS(postal_box)) OR EXISTS(town))

OR EXISTS(region)) OR EXISTS(postal_code)) OR EXISTS(country))

OR EXISTS(facsimile_number)) OR EXISTS(telephone_number)) OR

EXISTS(electronic_mail_address)) OR EXISTS(telex_number);

END_ENTITY; -- address

ENTITY advanced_brep_shape_representation

SUBTYPE OF (shape_representation);

WHERE

wr1: SIZEOF(QUERY ( it <* SELF.items | (NOT (SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.MANIFOLD_SOLID_BREP',

'DIMENSIONAL_INSPECTION_SCHEMA.FACETED_BREP',

'DIMENSIONAL_INSPECTION_SCHEMA.MAPPED_ITEM',

'DIMENSIONAL_INSPECTION_SCHEMA.AXIS2_PLACEMENT_3D'] *

TYPEOF(it)) = 1)) )) = 0;

wr2: SIZEOF(QUERY ( it <* SELF.items | (SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.MANIFOLD_SOLID_BREP',

'DIMENSIONAL_INSPECTION_SCHEMA.MAPPED_ITEM'] * TYPEOF(it)) =

1) )) > 0;

wr3: SIZEOF(QUERY ( msb <* QUERY ( it <* SELF.items | (

'DIMENSIONAL_INSPECTION_SCHEMA.MANIFOLD_SOLID_BREP' IN

TYPEOF(it)) ) | (NOT (SIZEOF(QUERY ( csh <* msb_shells(msb)

| (NOT (SIZEOF(QUERY ( fcs <* csh\connected_face_set.

cfs_faces | (NOT (

'DIMENSIONAL_INSPECTION_SCHEMA.ADVANCED_FACE'

IN TYPEOF(fcs))) )) = 0)) )) = 0)) )) = 0;

wr4: SIZEOF(QUERY ( msb <* QUERY ( it <* items | (

'DIMENSIONAL_INSPECTION_SCHEMA.MANIFOLD_SOLID_BREP' IN

TYPEOF(it)) ) | (

'DIMENSIONAL_INSPECTION_SCHEMA.ORIENTED_CLOSED_SHELL' IN

TYPEOF(msb\manifold_solid_brep.outer)) )) = 0;

wr5: SIZEOF(QUERY ( brv <* QUERY ( it <* items | (

'DIMENSIONAL_INSPECTION_SCHEMA.BREP_WITH_VOIDS' IN TYPEOF(it)) )

| (NOT (SIZEOF(QUERY ( csh <* brv\brep_with_voids.voids |

csh\oriented_closed_shell.orientation )) = 0)) )) = 0;

wr6: SIZEOF(QUERY ( mi <* QUERY ( it <* items | (

'DIMENSIONAL_INSPECTION_SCHEMA.MAPPED_ITEM' IN TYPEOF(it)) )| (NOT

('DIMENSIONAL_INSPECTION_SCHEMA.ADVANCED_BREP_SHAPE_REPRESENTATION'

IN TYPEOF(mi\mapped_item.mapping_source.

mapped_representation))) )) = 0;

END_ENTITY; -- advanced_brep_shape_representation

ENTITY advanced_face

SUBTYPE OF (face_surface);

WHERE

wr1 : SIZEOF(['DIMENSIONAL_INSPECTION_SCHEMA.ELEMENTARY_SURFACE',

'DIMENSIONAL_INSPECTION_SCHEMA.B_SPLINE_SURFACE',

'DIMENSIONAL_INSPECTION_SCHEMA.SWEPT_SURFACE'] * TYPEOF(

face_geometry)) = 1;

wr2 : SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'DIMENSIONAL_INSPECTION_SCHEMA.EDGE_LOOP' IN TYPEOF(bnds.

bound)) ) | (NOT (SIZEOF(QUERY ( oe <* elp_fbnds.bound\path

.edge_list | (NOT (

'DIMENSIONAL_INSPECTION_SCHEMA.EDGE_CURVE' IN TYPEOF(oe\

oriented_edge.edge_element))) )) = 0)) )) = 0;

wr3 : SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'DIMENSIONAL_INSPECTION_SCHEMA.EDGE_LOOP' IN TYPEOF(bnds.

bound)) ) | (NOT (SIZEOF(QUERY ( oe <* elp_fbnds.bound\path

.edge_list | (NOT (SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.LINE',

'DIMENSIONAL_INSPECTION_SCHEMA.CONIC',

'DIMENSIONAL_INSPECTION_SCHEMA.POLYLINE',

'DIMENSIONAL_INSPECTION_SCHEMA.SURFACE_CURVE',

'DIMENSIONAL_INSPECTION_SCHEMA.B_SPLINE_CURVE'] * TYPEOF(oe

.edge_element\edge_curve.edge_geometry)) = 1)) )) = 0)) ))

= 0;

wr4 : SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'DIMENSIONAL_INSPECTION_SCHEMA.EDGE_LOOP' IN TYPEOF(bnds.

bound)) ) | (NOT (SIZEOF(QUERY ( oe <* elp_fbnds.bound\path

.edge_list | (NOT (((

'DIMENSIONAL_INSPECTION_SCHEMA.VERTEX_POINT' IN TYPEOF(oe\

edge.edge_start)) AND (

'DIMENSIONAL_INSPECTION_SCHEMA.CARTESIAN_POINT' IN TYPEOF(

oe\edge.edge_start\vertex_point.vertex_geometry))) AND ((

'DIMENSIONAL_INSPECTION_SCHEMA.VERTEX_POINT' IN TYPEOF(oe\

edge.edge_end)) AND (

'DIMENSIONAL_INSPECTION_SCHEMA.CARTESIAN_POINT' IN TYPEOF(

oe\edge.edge_end\vertex_point.vertex_geometry))))) )) = 0)) ))

= 0;

wr5 : SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'DIMENSIONAL_INSPECTION_SCHEMA.EDGE_LOOP' IN TYPEOF(bnds.

bound)) ) | ('DIMENSIONAL_INSPECTION_SCHEMA.ORIENTED_PATH'

IN TYPEOF(elp_fbnds.bound)) )) = 0;

wr6 : (NOT ('DIMENSIONAL_INSPECTION_SCHEMA.SWEPT_SURFACE' IN TYPEOF(

face_geometry))) OR (SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.LINE',

'DIMENSIONAL_INSPECTION_SCHEMA.CONIC',

'DIMENSIONAL_INSPECTION_SCHEMA.POLYLINE',

'DIMENSIONAL_INSPECTION_SCHEMA.B_SPLINE_CURVE'] * TYPEOF(

face_geometry\swept_surface.swept_curve)) = 1);

wr7 : SIZEOF(QUERY ( vlp_fbnds <* QUERY ( bnds <* bounds | (

'DIMENSIONAL_INSPECTION_SCHEMA.VERTEX_LOOP' IN TYPEOF(bnds.

bound)) ) | (NOT ((

'DIMENSIONAL_INSPECTION_SCHEMA.VERTEX_POINT' IN TYPEOF(

vlp_fbnds\face_bound.bound\vertex_loop.loop_vertex)) AND (

'DIMENSIONAL_INSPECTION_SCHEMA.CARTESIAN_POINT' IN TYPEOF(

vlp_fbnds\face_bound.bound\vertex_loop.loop_vertex\

vertex_point.vertex_geometry)))) )) = 0;

wr8 : SIZEOF(QUERY ( bnd <* bounds | (NOT (SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.EDGE_LOOP',

'DIMENSIONAL_INSPECTION_SCHEMA.VERTEX_LOOP'] * TYPEOF(bnd.

bound)) = 1)) )) = 0;

wr9 : SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <* bounds | (

'DIMENSIONAL_INSPECTION_SCHEMA.EDGE_LOOP' IN TYPEOF(bnds.

bound)) ) | (NOT (SIZEOF(QUERY ( oe <* elp_fbnds.bound\path

.edge_list | ((

'DIMENSIONAL_INSPECTION_SCHEMA.SURFACE_CURVE' IN TYPEOF(oe\

oriented_edge.edge_element\edge_curve.edge_geometry)) AND (

NOT (SIZEOF(QUERY ( sc_ag <* oe.edge_element\edge_curve.

edge_geometry\surface_curve.associated_geometry | (NOT (

'DIMENSIONAL_INSPECTION_SCHEMA.PCURVE' IN TYPEOF(sc_ag))) ))

= 0))) )) = 0)) )) = 0;

wr10: ((NOT ('DIMENSIONAL_INSPECTION_SCHEMA.SWEPT_SURFACE' IN

TYPEOF(face_geometry))) OR ((NOT (

'DIMENSIONAL_INSPECTION_SCHEMA.POLYLINE' IN TYPEOF(

face_geometry\swept_surface.swept_curve))) OR (SIZEOF(

face_geometry\swept_surface.swept_curve\polyline.points) >=

3))) AND (SIZEOF(QUERY ( elp_fbnds <* QUERY ( bnds <*

bounds | ('DIMENSIONAL_INSPECTION_SCHEMA.EDGE_LOOP' IN

TYPEOF(bnds.bound)) ) | (NOT (SIZEOF(QUERY ( oe <*

elp_fbnds.bound\path.edge_list | ((

'DIMENSIONAL_INSPECTION_SCHEMA.POLYLINE' IN TYPEOF(oe\

oriented_edge.edge_element\edge_curve.edge_geometry)) AND (

NOT (SIZEOF(oe\oriented_edge.edge_element\edge_curve.

edge_geometry\polyline.points) >= 3))) )) = 0)) )) = 0);

END_ENTITY; -- advanced_face

ENTITY angular_location

SUBTYPE OF (dimensional_location);

angle_selection : angle_relator;

END_ENTITY; -- angular_location

ENTITY angular_size

SUBTYPE OF (dimensional_size);

angle_selection : angle_relator;

END_ENTITY; -- angular_size

ENTITY angularity_tolerance

SUBTYPE OF (geometric_tolerance_with_datum_reference);

WHERE

wr1: SIZEOF(SELF\geometric_tolerance_with_datum_reference.

datum_system) < 3;

END_ENTITY; -- angularity_tolerance

ENTITY apex

SUBTYPE OF (derived_shape_aspect);

END_ENTITY; -- apex

ENTITY application_context;

application : label;

DERIVE

description : text := get_description_value(SELF);

id: identifier := get_id_value(SELF);

INVERSE

context_elements : SET [1:?] OF application_context_element FOR

frame_of_reference;

WHERE

wr1: SIZEOF(USEDIN(SELF,'DIMENSIONAL_INSPECTION_SCHEMA.' +

'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;

wr2: SIZEOF(USEDIN(SELF,'DIMENSIONAL_INSPECTION_SCHEMA.' +

'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;

END_ENTITY; -- application_context

ENTITY application_context_element

SUPERTYPE OF (ONEOF (product_context,product_definition_context));

name : label;

frame_of_reference : application_context;

END_ENTITY; -- application_context_element

ENTITY application_protocol_definition;

status : label;

application_interpreted_model_schema_name : label;

application_protocol_year : year_number;

application : application_context;

END_ENTITY; -- application_protocol_definition

ENTITY applied_area

SUBTYPE OF (shape_aspect);

WHERE

wr1: 'DIMENSIONAL_INSPECTION_SCHEMA.PRODUCT_DEFINITION_SHAPE' IN

TYPEOF(SELF.of_shape);

wr2: SIZEOF(QUERY ( pd <* USEDIN(SELF,

'DIMENSIONAL_INSPECTION_SCHEMA.PROPERTY_DEFINITION.DEFINITION')

| (NOT (SIZEOF(QUERY ( pdr <* USEDIN(pd,

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') | ((

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'SHAPE_REPRESENTATION_WITH_PARAMETERS') IN TYPEOF(pdr.

used_representation)) )) = 1)) )) = 0;

wr3: SIZEOF(QUERY ( pd <* USEDIN(SELF,

'DIMENSIONAL_INSPECTION_SCHEMA.PROPERTY_DEFINITION.DEFINITION')

| (NOT (SIZEOF(QUERY ( impl_rep <* QUERY ( pdr <* USEDIN(pd,

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') | ((

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'SHAPE_REPRESENTATION_WITH_PARAMETERS') IN TYPEOF(pdr.

used_representation)) ) | (NOT ((2 <= SIZEOF(impl_rep.

used_representation.items)) AND (SIZEOF(impl_rep.

used_representation.items) <= 3))) )) = 0)) )) = 0;

wr4: SIZEOF(QUERY ( pd <* USEDIN(SELF,

'DIMENSIONAL_INSPECTION_SCHEMA.PROPERTY_DEFINITION.DEFINITION')

| (SIZEOF(QUERY ( pdr <* USEDIN(pd,

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') | (((

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'SHAPE_REPRESENTATION_WITH_PARAMETERS') IN TYPEOF(pdr.

used_representation)) AND (SIZEOF(QUERY ( srwp_i <* pdr.

used_representation.items | (NOT (srwp_i.name IN [

'orientation','effective length','maximum length'])) )) > 0)) ))

= 0) )) = 0;

wr5: SIZEOF(QUERY ( pd <* USEDIN(SELF,

'DIMENSIONAL_INSPECTION_SCHEMA.PROPERTY_DEFINITION.DEFINITION')

| (NOT (SIZEOF(QUERY ( impl_rep <* QUERY ( pdr <* USEDIN(pd,

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') | ((

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'SHAPE_REPRESENTATION_WITH_PARAMETERS') IN TYPEOF(pdr.

used_representation)) ) | (NOT (SIZEOF(QUERY ( it <*

impl_rep.used_representation.items | ((SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.MEASURE_REPRESENTATION_ITEM',

'DIMENSIONAL_INSPECTION_SCHEMA.LENGTH_MEASURE_WITH_UNIT'] *

TYPEOF(it)) = 2) AND (it.name = 'effective length')) )) = 1)) ))

= 0)) )) <= 1;

wr6: SIZEOF(QUERY ( pd <* USEDIN(SELF,

'DIMENSIONAL_INSPECTION_SCHEMA.PROPERTY_DEFINITION.DEFINITION')

| (NOT (SIZEOF(QUERY ( impl_rep <* QUERY ( pdr <* USEDIN(pd,

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') | ((

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'SHAPE_REPRESENTATION_WITH_PARAMETERS') IN TYPEOF(pdr.

used_representation)) ) | (NOT (SIZEOF(QUERY ( it <*

impl_rep.used_representation.items | ((SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.MEASURE_REPRESENTATION_ITEM',

'DIMENSIONAL_INSPECTION_SCHEMA.LENGTH_MEASURE_WITH_UNIT'] *

TYPEOF(it)) = 2) AND (it.name = 'maximum length')) )) <= 1)) ))

= 0)) )) = 0;

wr7: SIZEOF(QUERY ( pd <* USEDIN(SELF,

'DIMENSIONAL_INSPECTION_SCHEMA.PROPERTY_DEFINITION.DEFINITION')

| (NOT (SIZEOF(QUERY ( impl_rep <* QUERY ( pdr <* USEDIN(pd,

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') | ((

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'SHAPE_REPRESENTATION_WITH_PARAMETERS') IN TYPEOF(pdr.

used_representation)) ) | (NOT (SIZEOF(QUERY ( it <*

impl_rep.used_representation.items | ((

'DIMENSIONAL_INSPECTION_SCHEMA.PLACEMENT' IN TYPEOF(it)) AND

(it.name = 'orientation')) )) = 1)) )) = 0)) )) = 0;

END_ENTITY; -- applied_area

ENTITY applied_date_assignment

SUBTYPE OF (date_assignment);

items : SET [1:?] OF date_item;

END_ENTITY; -- applied_date_assignment

ENTITY applied_document_reference

SUBTYPE OF (document_reference);

items : SET [1:?] OF document_reference_item;

END_ENTITY; -- applied_document_reference

ENTITY applied_organization_assignment

SUBTYPE OF (organization_assignment);

items : SET [1:?] OF organization_item;

END_ENTITY; -- applied_organization_assignment

ENTITY applied_person_organization_assignment

SUBTYPE OF (person_and_organization_assignment);

items : SET [1:?] OF person_and_organization_item;

END_ENTITY; -- applied_person_organization_assignment

ENTITY applied_security_classification_assignment

SUBTYPE OF (security_classification_assignment);

items : SET [1:?] OF security_classification_item;

END_ENTITY; -- applied_security_classification_assignment

ENTITY axis1_placement

SUBTYPE OF (placement);

axis : OPTIONAL direction;

DERIVE

z : direction := NVL(normalise(axis),dummy_gri || direction([0,0,1]));

WHERE

wr1: SELF\geometric_representation_item.dim = 3;

END_ENTITY; -- axis1_placement

ENTITY axis2_placement_2d

SUBTYPE OF (placement);

ref_direction : OPTIONAL direction;

DERIVE

p : LIST [2:2] OF direction := build_2axes(ref_direction);

WHERE

wr1: SELF\geometric_representation_item.dim = 2;

END_ENTITY; -- axis2_placement_2d

ENTITY axis2_placement_3d

SUBTYPE OF (placement);

axis: OPTIONAL direction;

ref_direction : OPTIONAL direction;

DERIVE

p : LIST [3:3] OF direction := build_axes(axis,ref_direction);

WHERE

wr1: SELF\placement.location.dim = 3;

wr2: (NOT EXISTS(axis)) OR (axis.dim = 3);

wr3: (NOT EXISTS(ref_direction)) OR (ref_direction.dim = 3);

wr4: ((NOT EXISTS(axis)) OR (NOT EXISTS(ref_direction))) OR (

cross_product(axis,ref_direction).magnitude > 0);

END_ENTITY; -- axis2_placement_3d

ENTITY b_spline_curve

SUPERTYPE OF (ONEOF (uniform_curve,b_spline_curve_with_knots,

quasi_uniform_curve,bezier_curve) ANDOR rational_b_spline_curve)

SUBTYPE OF (bounded_curve);

degree : INTEGER;

control_points_list : LIST [2:?] OF cartesian_point;

curve_form: b_spline_curve_form;

closed_curve : LOGICAL;

self_intersect : LOGICAL;

DERIVE

upper_index_on_control_points : INTEGER := SIZEOF(

control_points_list) - 1;

control_points : ARRAY [0:

upper_index_on_control_points] OF

cartesian_point := list_to_array(

control_points_list,0,

upper_index_on_control_points);

WHERE

wr1: ((('DIMENSIONAL_INSPECTION_SCHEMA.UNIFORM_CURVE' IN TYPEOF(SELF))

OR ('DIMENSIONAL_INSPECTION_SCHEMA.QUASI_UNIFORM_CURVE' IN

TYPEOF(SELF))) OR (

'DIMENSIONAL_INSPECTION_SCHEMA.BEZIER_CURVE' IN TYPEOF(SELF)))

OR (

'DIMENSIONAL_INSPECTION_SCHEMA.B_SPLINE_CURVE_WITH_KNOTS' IN

TYPEOF(SELF));

END_ENTITY; -- b_spline_curve

ENTITY b_spline_curve_with_knots

SUBTYPE OF (b_spline_curve);

knot_multiplicities : LIST [2:?] OF INTEGER;

knots : LIST [2:?] OF parameter_value;

knot_spec: knot_type;

DERIVE

upper_index_on_knots : INTEGER := SIZEOF(knots);

WHERE

wr1: constraints_param_b_spline(degree,upper_index_on_knots,

upper_index_on_control_points,knot_multiplicities,knots);

wr2: SIZEOF(knot_multiplicities) = upper_index_on_knots;

END_ENTITY; -- b_spline_curve_with_knots

ENTITY b_spline_surface

SUPERTYPE OF (ONEOF (b_spline_surface_with_knots,uniform_surface,

quasi_uniform_surface,bezier_surface) ANDOR

rational_b_spline_surface)

SUBTYPE OF (bounded_surface);

u_degree : INTEGER;

v_degree : INTEGER;

control_points_list : LIST [2:?] OF LIST [2:?] OF cartesian_point;

surface_form : b_spline_surface_form;

u_closed : LOGICAL;

v_closed : LOGICAL;

self_intersect : LOGICAL;

DERIVE

u_upper : INTEGER := SIZEOF(control_points_list) - 1;

v_upper : INTEGER := SIZEOF(control_points_list[1]) - 1;

control_points : ARRAY [0:u_upper] OF ARRAY [0:v_upper] OF

cartesian_point := make_array_of_array(

control_points_list,0,u_upper,0,v_upper);

WHERE

wr1: ((('DIMENSIONAL_INSPECTION_SCHEMA.UNIFORM_SURFACE' IN TYPEOF(

SELF)) OR (

'DIMENSIONAL_INSPECTION_SCHEMA.QUASI_UNIFORM_SURFACE' IN

TYPEOF(SELF))) OR (

'DIMENSIONAL_INSPECTION_SCHEMA.BEZIER_SURFACE' IN TYPEOF(

SELF))) OR (

'DIMENSIONAL_INSPECTION_SCHEMA.B_SPLINE_SURFACE_WITH_KNOTS'

IN TYPEOF(SELF));

END_ENTITY; -- b_spline_surface

ENTITY b_spline_surface_with_knots

SUBTYPE OF (b_spline_surface);

u_multiplicities : LIST [2:?] OF INTEGER;

v_multiplicities : LIST [2:?] OF INTEGER;

u_knots : LIST [2:?] OF parameter_value;

v_knots : LIST [2:?] OF parameter_value;

knot_spec : knot_type;

DERIVE

knot_u_upper : INTEGER := SIZEOF(u_knots);

knot_v_upper : INTEGER := SIZEOF(v_knots);

WHERE

wr1: constraints_param_b_spline(SELF\b_spline_surface.u_degree,

knot_u_upper,SELF\b_spline_surface.u_upper,u_multiplicities,

u_knots);

wr2: constraints_param_b_spline(SELF\b_spline_surface.v_degree,

knot_v_upper,SELF\b_spline_surface.v_upper,v_multiplicities,

v_knots);

wr3: SIZEOF(u_multiplicities) = knot_u_upper;

wr4: SIZEOF(v_multiplicities) = knot_v_upper;

END_ENTITY; -- b_spline_surface_with_knots

ENTITY bezier_curve

SUBTYPE OF (b_spline_curve);

END_ENTITY; -- bezier_curve

ENTITY bezier_surface

SUBTYPE OF (b_spline_surface);

END_ENTITY; -- bezier_surface

ENTITY block_shape_representation

SUBTYPE OF (shape_representation_with_parameters);

WHERE

wr1: SIZEOF(SELF.items) = 4;

wr2: SIZEOF(QUERY ( it <* SELF.items | ((

'DIMENSIONAL_INSPECTION_SCHEMA.PLACEMENT' IN TYPEOF(it)) AND

(it.name = 'orientation')) )) = 1;

wr3: SIZEOF(QUERY ( it <* SELF.items | ((SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.MEASURE_REPRESENTATION_ITEM',

'DIMENSIONAL_INSPECTION_SCHEMA.LENGTH_MEASURE_WITH_UNIT'] *

TYPEOF(it)) = 2) AND (it.name = 'length')) )) = 1;

wr4: SIZEOF(QUERY ( it <* SELF.items | ((SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.MEASURE_REPRESENTATION_ITEM',

'DIMENSIONAL_INSPECTION_SCHEMA.LENGTH_MEASURE_WITH_UNIT'] *

TYPEOF(it)) = 2) AND (it.name = 'width')) )) = 1;

wr5: SIZEOF(QUERY ( it <* SELF.items | ((SIZEOF([

'DIMENSIONAL_INSPECTION_SCHEMA.MEASURE_REPRESENTATION_ITEM',

'DIMENSIONAL_INSPECTION_SCHEMA.LENGTH_MEASURE_WITH_UNIT'] *

TYPEOF(it)) = 2) AND (it.name = 'height')) )) = 1;

END_ENTITY; -- block_shape_representation

ENTITY boss

SUBTYPE OF (feature_definition);

WHERE

wr1 : SELF\characterized_object.description IN ['circular','complex',

'rectangular'];

wr2 : SIZEOF(QUERY ( pds <* QUERY ( pd <* USEDIN(SELF,

'DIMENSIONAL_INSPECTION_SCHEMA.PROPERTY_DEFINITION.DEFINITION')

| (

'DIMENSIONAL_INSPECTION_SCHEMA.PRODUCT_DEFINITION_SHAPE' IN

TYPEOF(pd)) ) | (NOT (SIZEOF(QUERY ( sa_occ <* USEDIN(pds,

'DIMENSIONAL_INSPECTION_SCHEMA.SHAPE_ASPECT.OF_SHAPE') | ((

sa_occ.description = 'boss height occurrence') AND (SIZEOF(

QUERY ( sdr <* QUERY ( sar <* USEDIN(sa_occ,

'DIMENSIONAL_INSPECTION_SCHEMA.SHAPE_ASPECT_RELATIONSHIP.'

+ 'RELATED_SHAPE_ASPECT') | ((sar.description =

'path feature component usage') AND ((

'DIMENSIONAL_INSPECTION_SCHEMA.' +

'SHAPE_DEFINING_RELATIONSHIP') IN TYPEOF(sar))) ) | (((

'DIMENSIONAL_INSPECTION_SCHEMA.PATH_FEATURE_COMPONENT' IN

TYPEOF(sdr.relating_shape_aspect)) AND (sdr.