# $RCSfile: ap242_managed_model_based_3d_engineering_mim_lf.ws,v $ # $Revision: 1.1 $ $Date: 2012/01/05 19:13:10 $ # Auth: Dave Loffredo (loffredo@steptools.com) # # WORKING SET - AP242 # # This working set file lists the permitted entities and complex # entities for working with AP242, which combines AP203 and AP214. # # To see how to use working sets with the EXPRESS compiler, consult # the EXPRESS compiler section of the STEP Utilities reference manual. # This file is specified using the -ws option to the compiler # # % expfront -ws workset.ws schema.exp # SCHEMA ap242_managed_model_based_3d_engineering_mim_lf \ -all -p28ns urn:oid:1.0.10303.242.1.0.0 #======================================== # AND/OR Combinations for creating complex types # # Note that we manually specify a name for each so we can condense the # names and keep uniform ordering of elements in blocks of similar # ones. By default, the names are put together in alphabetical order # rather than the way they are listed in the ANDOR() statement. # # # Unit Descriptions # area_unit and volume_unit are deprecated and should not be used. # ANDOR( si_unit length_unit ) ANDOR( si_unit mass_unit ) ANDOR( si_unit plane_angle_unit ) ANDOR( si_unit solid_angle_unit ) ANDOR( si_unit ratio_unit ) ANDOR( si_unit time_unit ) # no conversion based solid angle or ratio ANDOR( conversion_based_unit length_unit ) ANDOR( conversion_based_unit mass_unit ) ANDOR( conversion_based_unit plane_angle_unit ) ANDOR( conversion_based_unit time_unit ) # Measure Descriptions -- The length and plane measures may also be # combined with a qualified rep item, to handle plus minus ranges or # precisions. Qualified lengths are widely used but qualified angles # may also appear in data imported from AP-224. # # area/volume_measure_with_unit are deprecated and should not be used. # ANDOR( measure_representation_item length_measure_with_unit ) ANDOR( measure_representation_item length_measure_with_unit \ qualified_representation_item ) ANDOR( measure_representation_item mass_measure_with_unit ) ANDOR( measure_representation_item mass_measure_with_unit \ qualified_representation_item ) ANDOR( measure_representation_item plane_angle_measure_with_unit ) ANDOR( measure_representation_item plane_angle_measure_with_unit \ qualified_representation_item ) ANDOR( measure_representation_item time_measure_with_unit ) ANDOR( measure_representation_item time_measure_with_unit \ qualified_representation_item ) # for qualified speeds and pressures ANDOR( measure_representation_item qualified_representation_item ) # for percentage measures ANDOR( measure_representation_item ratio_measure_with_unit ) # # Contexts and relationships # ANDOR( geometric_representation_context \ global_uncertainty_assigned_context \ global_unit_assigned_context ) ANDOR( geometric_representation_context \ global_unit_assigned_context ) ANDOR( geometric_representation_context \ parametric_representation_context ) # Needed for using pcurves w/breps ANDOR( definitional_representation \ shape_representation ) ANDOR( representation_relationship_with_transformation \ shape_representation_relationship ) # # Spline curves and surfaces (NURBS) # ANDOR( rational_b_spline_curve b_spline_curve_with_knots ) ANDOR( rational_b_spline_curve bezier_curve ) ANDOR( rational_b_spline_curve quasi_uniform_curve ) ANDOR( rational_b_spline_curve uniform_curve ) ANDOR( rational_b_spline_surface b_spline_surface_with_knots ) ANDOR( rational_b_spline_surface bezier_surface ) ANDOR( rational_b_spline_surface quasi_uniform_surface ) ANDOR( rational_b_spline_surface uniform_surface ) # Not in ap238dis, but in other aps. This is 203cc5 I think. ANDOR( brep_with_voids faceted_brep ) # # Features -- Everything except transition features are combined with # instanced_feature. Instanced feature is a subtype of shape_aspect, # which gives us the means to hook the feature to a shape. # # Note that replicate feature is never created directly, so it is not # here, but all of the subtypes are. # # A feature might appear as a datum for a geometric tolerance. When # this happens, it must form a complex instance with datum_feature. # # To keep things consistent for the programmer, we always have the # feature first in the name. I have also abbreviated the datum case # slightly: # _and_instanced_feature # _and_instanced_datum_feature ANDOR( instanced_feature boss ) ANDOR( instanced_feature boss \ datum_feature ) ANDOR( instanced_feature circular_pattern ) ANDOR( instanced_feature circular_pattern \ datum_feature ) ANDOR( instanced_feature composite_hole ) ANDOR( instanced_feature composite_hole \ datum_feature ) ANDOR( instanced_feature compound_feature ) ANDOR( instanced_feature compound_feature \ datum_feature ) ANDOR( instanced_feature externally_defined_feature_definition ) ANDOR( instanced_feature externally_defined_feature_definition \ datum_feature ) ANDOR( instanced_feature feature_pattern ) ANDOR( instanced_feature feature_pattern \ datum_feature ) ANDOR( instanced_feature flat_face ) ANDOR( instanced_feature flat_face \ datum_feature ) ANDOR( instanced_feature gear ) ANDOR( instanced_feature gear \ datum_feature ) ANDOR( instanced_feature outside_profile ) ANDOR( instanced_feature outside_profile \ datum_feature ) ANDOR( instanced_feature pocket ) ANDOR( instanced_feature pocket \ datum_feature ) ANDOR( instanced_feature rectangular_pattern ) ANDOR( instanced_feature rectangular_pattern \ datum_feature ) ANDOR( instanced_feature removal_volume ) ANDOR( instanced_feature removal_volume \ datum_feature ) ANDOR( instanced_feature round_hole ) ANDOR( instanced_feature round_hole \ datum_feature ) ANDOR( instanced_feature rounded_end ) ANDOR( instanced_feature rounded_end \ datum_feature ) ANDOR( instanced_feature slot ) ANDOR( instanced_feature slot \ datum_feature ) ANDOR( instanced_feature spherical_cap ) ANDOR( instanced_feature spherical_cap \ datum_feature ) ANDOR( instanced_feature step ) ANDOR( instanced_feature step \ datum_feature ) ANDOR( instanced_feature thread ) ANDOR( instanced_feature thread \ datum_feature ) ANDOR( datum_feature chamfer ) ANDOR( datum_feature edge_round ) # -------------------- # Turning features # ANDOR( instanced_feature outer_round ) ANDOR( instanced_feature outer_round \ datum_feature ) ANDOR( instanced_feature revolved_profile ) ANDOR( instanced_feature revolved_profile \ datum_feature ) ANDOR( instanced_feature turned_knurl ) ANDOR( instanced_feature turned_knurl \ datum_feature ) # -------------------- # Other features # ANDOR( instanced_feature marking ) ANDOR( instanced_feature protrusion ) ANDOR( instanced_feature rib_top ) # -------------------- # General features -- used identifying machine points in kinematics models # ANDOR( instanced_feature general_feature ) ANDOR( instanced_feature general_feature composite_shape_aspect ) # ============================================================ # GD&T Definitions # # The way the GD&T definitions are handled in STEP requires a fair # number of complex types. In particular, optional components of some # tolerances are handled by adding a type as a complex. Keeping this # in mind, you will see that most of the complex types below are just # adding a path, modification, or measurement segment size to one of # the base geometric tolerance types from AIC 519. # # DIMENSIONS -- the externally defined size dimension can form a # complex instance if a path is specified, and the location dimensions # form a complex instance if they are "directed" # ANDOR( externally_defined_dimension_definition \ dimensional_size_with_path ) ANDOR( directed_dimensional_location angular_location ) ANDOR( directed_dimensional_location dimensional_location_with_path ) # DATUMS based on derived shapes -- These are represented as a complex # instance of datum plus derived_shape_aspect or one of the subtypes. # ANDOR( datum derived_shape_aspect ) ANDOR( datum apex ) ANDOR( datum centre_of_symmetry ) ANDOR( datum extension ) ANDOR( datum geometric_alignment ) ANDOR( datum geometric_intersection ) ANDOR( datum parallel_offset ) ANDOR( datum perpendicular_to ) ANDOR( datum tangent ) # TOLERANCES -- The geometric tolerances can form a complex instance # with "modified geometric tolerance" to add a condition like maximum # material extent. The can also be combines with "geometric tolerance # with defined unit" to specify a segment size. The AP-214/1050 ARM # allows this for any, but AP-224 restricts to angularity, flatness, # parallelism, perpendicularity, and straightness. # # The position, line profile, and surface profile tolerances can also # be associated with a datum reference, so we need a complex instance # that includes that GTWDR as well. This is a bit unwieldy, but that # is the way it was modeled. # # Concatenating the names with _and_ gets a bit insane, so provide our # own by adding the modified_ or _with_defined_unit bits to the base. # ANDOR( angularity_tolerance modified_geometric_tolerance ) ANDOR( angularity_tolerance geometric_tolerance_with_defined_unit ) ANDOR( angularity_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( circular_runout_tolerance modified_geometric_tolerance ) ANDOR( circular_runout_tolerance geometric_tolerance_with_defined_unit ) ANDOR( circular_runout_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( coaxiality_tolerance modified_geometric_tolerance ) ANDOR( coaxiality_tolerance geometric_tolerance_with_defined_unit ) ANDOR( coaxiality_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( concentricity_tolerance modified_geometric_tolerance ) ANDOR( concentricity_tolerance geometric_tolerance_with_defined_unit ) ANDOR( concentricity_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( cylindricity_tolerance modified_geometric_tolerance ) ANDOR( cylindricity_tolerance geometric_tolerance_with_defined_unit ) ANDOR( cylindricity_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( flatness_tolerance modified_geometric_tolerance ) ANDOR( flatness_tolerance geometric_tolerance_with_defined_unit ) ANDOR( flatness_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( line_profile_tolerance modified_geometric_tolerance ) ANDOR( line_profile_tolerance geometric_tolerance_with_defined_unit ) ANDOR( line_profile_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) # Line profile may have datums, so we need these combinations too ANDOR( line_profile_tolerance geometric_tolerance_with_datum_reference ) ANDOR( line_profile_tolerance geometric_tolerance_with_datum_reference \ modified_geometric_tolerance ) ANDOR( line_profile_tolerance geometric_tolerance_with_datum_reference \ geometric_tolerance_with_defined_unit ) ANDOR( line_profile_tolerance geometric_tolerance_with_datum_reference \ geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( parallelism_tolerance modified_geometric_tolerance ) ANDOR( parallelism_tolerance geometric_tolerance_with_defined_unit ) ANDOR( parallelism_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( perpendicularity_tolerance modified_geometric_tolerance ) ANDOR( perpendicularity_tolerance geometric_tolerance_with_defined_unit ) ANDOR( perpendicularity_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( position_tolerance modified_geometric_tolerance ) ANDOR( position_tolerance geometric_tolerance_with_defined_unit ) ANDOR( position_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) # Positions may have datums, so we need these combinations too ANDOR( position_tolerance geometric_tolerance_with_datum_reference ) ANDOR( position_tolerance geometric_tolerance_with_datum_reference \ modified_geometric_tolerance ) ANDOR( position_tolerance geometric_tolerance_with_datum_reference \ geometric_tolerance_with_defined_unit ) ANDOR( position_tolerance geometric_tolerance_with_datum_reference \ geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( roundness_tolerance modified_geometric_tolerance ) ANDOR( roundness_tolerance geometric_tolerance_with_defined_unit ) ANDOR( roundness_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( straightness_tolerance modified_geometric_tolerance ) ANDOR( straightness_tolerance geometric_tolerance_with_defined_unit ) ANDOR( straightness_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( surface_profile_tolerance modified_geometric_tolerance ) ANDOR( surface_profile_tolerance geometric_tolerance_with_defined_unit ) ANDOR( surface_profile_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) # Surface profiles may have datums, so we need these combinations too ANDOR( surface_profile_tolerance geometric_tolerance_with_datum_reference ) ANDOR( surface_profile_tolerance geometric_tolerance_with_datum_reference \ modified_geometric_tolerance ) ANDOR( surface_profile_tolerance geometric_tolerance_with_datum_reference \ geometric_tolerance_with_defined_unit ) ANDOR( surface_profile_tolerance geometric_tolerance_with_datum_reference \ geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( symmetry_tolerance modified_geometric_tolerance ) ANDOR( symmetry_tolerance geometric_tolerance_with_defined_unit ) ANDOR( symmetry_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) ANDOR( total_runout_tolerance modified_geometric_tolerance ) ANDOR( total_runout_tolerance geometric_tolerance_with_defined_unit ) ANDOR( total_runout_tolerance geometric_tolerance_with_defined_unit \ modified_geometric_tolerance ) # This is not in the ARM, but is an artifact from some early tests # where the type was given as a string rather than a subtypes ANDOR( modified_geometric_tolerance geometric_tolerance_with_datum_reference ) # ============================================================ # AP203/AP224 Definitions # # These definitions do not apply to AP238, but are found in the other # APs covered by the merged step_manufacturing_schema # # Assemblies # ANDOR( next_assembly_usage_occurrence \ quantified_assembly_component_usage ) # Effectivities # ANDOR( configuration_effectivity dated_effectivity ) ANDOR( configuration_effectivity lot_effectivity ) ANDOR( configuration_effectivity serial_numbered_effectivity ) # # Complex instances for Drafting and Presentation # # The mappings seem to require the elements andor for any dimension # but it is not clear whether anyone actually uses it this way. It # looks like 203e2 may have dropped draughting_elements. # ANDOR( draughting_elements angular_dimension ) ANDOR( draughting_elements curve_dimension ) ANDOR( draughting_elements diameter_dimension ) ANDOR( draughting_elements leader_directed_dimension ) ANDOR( draughting_elements linear_dimension ) ANDOR( draughting_elements ordinate_dimension ) ANDOR( draughting_elements radius_dimension ) ANDOR( draughting_elements structured_dimension_callout ) ANDOR( draughting_annotation_occurrence annotation_curve_occurrence ) ANDOR( draughting_annotation_occurrence annotation_fill_area_occurrence ) ANDOR( draughting_annotation_occurrence annotation_symbol_occurrence ) ANDOR( draughting_annotation_occurrence annotation_text_occurrence ) ANDOR( draughting_annotation_occurrence dimension_curve ) ANDOR( draughting_annotation_occurrence dimension_curve_terminator ) ANDOR( draughting_annotation_occurrence leader_curve ) ANDOR( draughting_annotation_occurrence leader_terminator ) ANDOR( draughting_annotation_occurrence projection_curve ) ANDOR( text_style_with_mirror text_style_with_box_characteristics ) ANDOR( text_style_with_mirror text_style_with_spacing ) # All possible test styling options. Neither AP203 or AP214 mappings # seem to use the spacing option, but it seems semantically valid so # support it to. ANDOR( text_style_with_mirror text_style_with_spacing ) ANDOR( text_style_with_box_characteristics text_style_with_mirror ) ANDOR( text_style_with_box_characteristics text_style_with_spacing ) ANDOR( text_style_with_box_characteristics text_style_with_spacing \ text_style_with_mirror ) # The mapping tables do not seem to call for GRI, but there is a # CAX-IF example document that uses them, probably mistakenly. # ANDOR( draughting_annotation_occurrence geometric_representation_item \ annotation_text_occurrence ) ANDOR( draughting_annotation_occurrence geometric_representation_item \ leader_curve ) ANDOR( draughting_annotation_occurrence geometric_representation_item \ leader_terminator ) # This does not make a lot of sense either. ANDOR( geometric_representation_item camera_image_2d_with_scale ) ANDOR( geometric_representation_item camera_image_3d_with_scale )