ISO/TS 10303-1654:2018-11 Characteristic


Application module: Characteristic	ISO/TS 10303-1654:2018-11(E) © ISO

Cover page
Table of contents
Copyright
Foreword
Introduction
1 Scope
2 Normative references
3 Terms, definitions and abbreviated terms
3.1 Terms and definitions
3.2 Abbreviated terms

4 Information requirements
4.1 Required AM ARMs
4.2 ARM type definitions
4.3 ARM entity definitions
4.4 ARM subtype constraint definitions
4.5 ARM function definitions
5 Module interpreted model
5.1 Mapping specification
5.2 MIM EXPRESS short listing
5.2.1 MIM type definition
5.2.2 MIM entity definitions
5.2.3 MIM subtype constraint definition

A MIM short names
B Information object registration
C ARM EXPRESS-G
D MIM EXPRESS-G
E Computer interpretable listings
F Change history
Bibliography
Index


         (*
ISO/TC 184/SC 4/WG 12 N9602 - ISO/TS 10303-1654 Characteristic - EXPRESS ARM
Supersedes 
         ISO/TC 184/SC 4/WG 12 N7957
*)



SCHEMA Characteristic_arm;


         USE FROM
         Basic_data_representation_arm;
            -- ISO/TS 10303-1773


         USE FROM
         Document_assignment_arm;
            -- ISO/TS 10303-1122


         USE FROM
         Extended_measure_representation_arm;
            -- ISO/TS 10303-1106


         USE FROM
         External_library_arm;
            -- ISO/TS 10303-1778


         USE FROM
         Value_with_unit_extension_arm;
            -- ISO/TS 10303-1753


         USE FROM
         External_properties_arm;
            -- ISO/TS 10303-1129


         USE FROM
         Property_assignment_arm;
            -- ISO/TS 10303-1030


         REFERENCE FROM 
         Support_resource_arm   -- ISO/TS 10303-1800
  (bag_to_set);


         REFERENCE FROM 
         Qualified_measure_arm   -- ISO/TS 10303-1782
  (pre_defined_type_qualifiers);


TYPE c_documented_element_select =
         
         
         SELECT
         BASED_ON
         documented_element_select
         WITH 
         

            (Property_value_representation);

         END_TYPE;


TYPE characteristic =
         
         
         SELECT

            (String_representation_item, 
    Numerical_item_with_unit, 
    Value_list, 
    Value_set);

         END_TYPE;


TYPE characteristic_data_table_cell =
         
         
         SELECT

            (Null_representation_item, 
    String_representation_item, 
    Numerical_item_with_global_unit, 
    Numerical_item_with_unit, 
    Value_list, 
    Value_set);

         END_TYPE;


TYPE range_class =
         
         ENUMERATION
         
         OF
         

            
         (closed,
    lower_open,
    upper_open,
    open);

         END_TYPE;


TYPE scalar_or_coordinated_characteristics =
         
         
         SELECT

            (Property_value_representation, 
    characteristic);

         END_TYPE;


ENTITY Characteristic_data_column_header

           SUBTYPE OF (Independent_property);
INVERSE

           table_header_usage : Characteristic_data_table_header_decomposition FOR related;

         
         END_ENTITY;


ENTITY Characteristic_data_column_header_link

           SUBTYPE OF (Independent_property_relationship);

           SELF\Independent_property_relationship.relating RENAMED precedent : Characteristic_data_column_header;

           SELF\Independent_property_relationship.related RENAMED subsequent : Characteristic_data_column_header;
DERIVE

           SELF\Independent_property_relationship.relation_type : STRING := 'sequence';
UNIQUE

           UR1: precedent, subsequent;
WHERE

           WR1: subsequent <> precedent;

         
         END_ENTITY;


ENTITY Characteristic_data_table

           SUBTYPE OF (Representation_item);

           property_value : LIST[1:?] OF Characteristic_data_table_row;
WHERE

           WR1: SIZEOF(QUERY( pv <* property_value |
            NOT (SIZEOF(pv.cell) = SIZEOF(property_value[1].cell))
            )) = 0;

         
         END_ENTITY;


ENTITY Characteristic_data_table_header

           SUBTYPE OF (Independent_property);
INVERSE

           column : SET[2:?] OF Characteristic_data_table_header_decomposition FOR relating;

         
         END_ENTITY;


ENTITY Characteristic_data_table_header_decomposition

           SUBTYPE OF (Independent_property_relationship);

           SELF\Independent_property_relationship.relating : Characteristic_data_table_header;

           SELF\Independent_property_relationship.related : Characteristic_data_column_header;
DERIVE

           SELF\Independent_property_relationship.relation_type : STRING := 'decomposition';

         
         END_ENTITY;


ENTITY Characteristic_data_table_header_usage

           SUBTYPE OF (Property_definition_representation);

           SELF\Property_definition_representation.definition : Characteristic_data_table_header;

           SELF\Property_definition_representation.used_representation : Characteristic_data_table_representation;

         
         END_ENTITY;


ENTITY Characteristic_data_table_representation

           SUBTYPE OF (Property_value_representation);

           SELF\Representation.items : SET[1:1] OF Characteristic_data_table;
INVERSE

           header : Characteristic_data_table_header_usage FOR used_representation;

         
         END_ENTITY;


ENTITY Characteristic_data_table_row

           SUBTYPE OF (Representation_item);

           cell : LIST[1:?] OF characteristic_data_table_cell;

         
         END_ENTITY;


ENTITY Correlated_property

           SUBTYPE OF (Assigned_property);

           correlated_properties : SET[1:?] OF Assigned_property;
WHERE

           WR1: SIZEOF(QUERY(cp <* correlated_properties | cp\Assigned_property.described_element <> SELF\Assigned_property.described_element))
            = 0;

         
         END_ENTITY;


ENTITY Externally_defined_type_qualifier

           SUBTYPE OF (Type_qualifier);

           external_source : External_source;
WHERE

           WR1: NOT(name IN pre_defined_type_qualifiers);

         
         END_ENTITY;


ENTITY Length_tolerance_characteristic

           SUBTYPE OF (Tolerance_characteristic);
WHERE

           WR1: ('CHARACTERISTIC_ARM.STATISTICAL_TOLERANCE_CHARACTERISTIC' IN TYPEOF(SELF)) OR
            ('CHARACTERISTIC_ARM.SYMMETRICAL_TOLERANCE_CHARACTERISTIC' IN TYPEOF(SELF)) OR
            ('CHARACTERISTIC_ARM.PLUS_MINUS_TOLERANCE_CHARACTERISTIC' IN TYPEOF(SELF)) OR
            (SIZEOF(QUERY(it <* SELF\Representation.items |
            NOT('VALUE_WITH_UNIT_EXTENSION_ARM.LENGTH_DATA_ELEMENT' IN TYPEOF(it))
            )) = 0);

           WR2: NOT('CHARACTERISTIC_ARM.SYMMETRICAL_TOLERANCE_CHARACTERISTIC' IN TYPEOF(SELF)) OR
            (SIZEOF(QUERY(it <* SELF\Representation.items |
            ('VALUE_WITH_UNIT_EXTENSION_ARM.LENGTH_DATA_ELEMENT' IN TYPEOF(it))
            )) = 1);

           WR3: NOT('CHARACTERISTIC_ARM.STATISTICAL_TOLERANCE_CHARACTERISTIC' IN TYPEOF(SELF)) OR
            (SIZEOF(QUERY(it <* SELF\Representation.items |
            ('VALUE_WITH_UNIT_EXTENSION_ARM.LENGTH_DATA_ELEMENT' IN TYPEOF(it))
            )) = 1);

           WR4: NOT EXISTS(SELF\Representation.description);

           WR5: NOT('CHARACTERISTIC_ARM.PLUS_MINUS_TOLERANCE_CHARACTERISTIC' IN TYPEOF(SELF)) OR
            (SIZEOF(QUERY(it <* SELF\Representation.items |
            NOT(('EXTENDED_MEASURE_REPRESENTATION_ARM.VALUE_WITH_TOLERANCES' IN TYPEOF(it)) AND
            ('VALUE_WITH_UNIT_EXTENSION_ARM.LENGTH_DATA_ELEMENT' IN TYPEOF(it\Value_with_tolerances.item_value)))
            )) = 0);

         
         END_ENTITY;


ENTITY Maximum_tolerance_characteristic

           SUBTYPE OF (Tolerance_characteristic);

           SELF\Representation.items : SET[1:1] OF Value_limit;
WHERE

           WR1: SELF\Representation.items[1]\Value_limit.qualifiers[1]\Type_qualifier.name = 'maximum';

         
         END_ENTITY;


ENTITY Minimum_tolerance_characteristic

           SUBTYPE OF (Tolerance_characteristic);

           SELF\Representation.items : SET[1:1] OF Value_limit;
WHERE

           WR1: SELF\Representation.items[1]\Value_limit.qualifiers[1]\Type_qualifier.name = 'minimum';

         
         END_ENTITY;


ENTITY Nominal_tolerance_characteristic

           SUBTYPE OF (Tolerance_characteristic);

           SELF\Representation.items : SET[1:1] OF Qualified_numerical_item_with_unit;
WHERE

           WR1: SELF\Representation.items[1]\Qualified_representation_item.qualifiers[1]\Type_qualifier.name = 'nominal';

         
         END_ENTITY;


ENTITY Null_representation_item

           SUBTYPE OF (Representation_item);

         
         END_ENTITY;


ENTITY Plus_minus_tolerance_characteristic

           SUBTYPE OF (Tolerance_characteristic);

           SELF\Representation.items : SET[1:1] OF Value_with_tolerances;

         
         END_ENTITY;


ENTITY Qualified_tolerance_characteristic

           SUBTYPE OF (Tolerance_characteristic);

           SELF\Representation.items : SET[1:4] OF Qualified_numerical_item_with_unit;
WHERE

           WR1: valid_qualified_tolerance_characteristic(SELF);

         
         END_ENTITY;


ENTITY Range_characteristic

           SUBTYPE OF (Property_value_representation);

           SELF\Representation.items : SET[2:2] OF Numerical_item_with_unit;

           range_type : range_class;
WHERE

           WR1: TYPEOF(SELF\Representation.items[1]) =
            TYPEOF(SELF\Representation.items[2]);

           WR2: TYPEOF(SELF\Representation.items[1]\Value_with_unit.unit) =
            TYPEOF(SELF\Representation.items[2]\Value_with_unit.unit);

           WR3: valid_range(SELF\Representation.items[1],
            SELF\Representation.items[2]);

         
         END_ENTITY;


ENTITY Statistical_tolerance_characteristic

           SUBTYPE OF (Tolerance_characteristic);

           SELF\Representation.items : SET[2:?] OF Numerical_item_with_unit;

         
         END_ENTITY;


ENTITY Symmetrical_tolerance_characteristic

           SUBTYPE OF (Tolerance_characteristic);

           SELF\Representation.items : SET[2:2] OF Numerical_item_with_unit;
WHERE

           WR1: SIZEOF(QUERY( ri <* 
            SELF\representation.items |
            'VALUE_WITH_UNIT_EXTENSION_ARM.RATIO_DATA_ELEMENT' IN TYPEOF(ri))) = 1;

         
         END_ENTITY;


ENTITY Text_representation_item

           SUBTYPE OF (String_representation_item);

         
         END_ENTITY;


ENTITY Tolerance_characteristic

           ABSTRACT SUPERTYPE
         
         OF (ONEOF (Maximum_tolerance_characteristic,
                                Minimum_tolerance_characteristic,
                                Nominal_tolerance_characteristic,
                                Plus_minus_tolerance_characteristic,
                                Qualified_tolerance_characteristic,
                                Statistical_tolerance_characteristic,
                                Symmetrical_tolerance_characteristic,
                                Typical_tolerance_characteristic)
                        ANDOR Length_tolerance_characteristic)

           SUBTYPE OF (Property_value_representation);
WHERE

           WR1: SELF\Representation.context_of_items\Representation_context.id = 'tolerance values';

           WR2: NOT EXISTS(SELF\Representation.name);

         
         END_ENTITY;


ENTITY Typical_tolerance_characteristic

           SUBTYPE OF (Tolerance_characteristic);

           SELF\Representation.items : SET[1:1] OF Value_limit;
WHERE

           WR1: SELF\Representation.items[1]\Value_limit.qualifiers[1]\Type_qualifier.name = 'typical';

         
         END_ENTITY;


SUBTYPE_CONSTRAINT c_representation_item_subtypes FOR Representation_item;

           ONEOF (Characteristic_data_table,
         Characteristic_data_table_row);
      
         END_SUBTYPE_CONSTRAINT;


SUBTYPE_CONSTRAINT exclusive_property_value_representation_characteristic FOR Property_value_representation;

           ONEOF (Range_characteristic,
         Tolerance_characteristic);
      
         END_SUBTYPE_CONSTRAINT;


SUBTYPE_CONSTRAINT independent_property_subtypes FOR Independent_property;

           ONEOF (Characteristic_data_table_header,
         Characteristic_data_column_header);
      
         END_SUBTYPE_CONSTRAINT;


SUBTYPE_CONSTRAINT type_qualifier_subtypes FOR Type_qualifier;

           ONEOF (Externally_defined_type_qualifier,
         Pre_defined_type_qualifier);
      
         END_SUBTYPE_CONSTRAINT;


FUNCTION valid_qualified_tolerance_characteristic
 (input : Qualified_tolerance_characteristic) : BOOLEAN;

LOCAL
     bag_data : BAG OF STRING := [];
     valid_set : SET OF STRING := ['nominal', 'typical' , 'maximum', 'minimum'];
  END_LOCAL;
  REPEAT i := 1 TO SIZEOF(input\Qualified_tolerance_characteristic.items);
    REPEAT j := 1 TO SIZEOF(input\Qualified_tolerance_characteristic.items[i]\Qualified_representation_item.qualifiers);
     IF 'QUALIFIED_MEASURE_ARM.TYPE_QUALIFIER' IN TYPEOF(input\Qualified_tolerance_characteristic.items[i]\Qualified_representation_item.qualifiers[j])
      THEN
        bag_data := bag_data + input\Qualified_tolerance_characteristic.items[i]\Qualified_representation_item.qualifiers[j]\Type_qualifier.name;
     END_IF;
    END_REPEAT;
  END_REPEAT;

  IF (SIZEOF(bag_to_set(bag_data)) = SIZEOF(bag_data)) AND
     (VALUE_UNIQUE(bag_data)) AND 
     (SIZEOF(valid_set * bag_data) = SIZEOF(bag_data)) 
  THEN RETURN(TRUE);
  END_IF;
    
   RETURN(FALSE);


         END_FUNCTION;


FUNCTION valid_range
 (input1 : Numerical_item_with_unit; input2 : Numerical_item_with_unit) : BOOLEAN;

RETURN(TRUE);


         END_FUNCTION;



         END_SCHEMA;  -- Characteristic_arm