Integrated generic resource: Product structure configuration ISO 10303-44:2021(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 Product structure
   4.1 General
   4.2 Fundamental concepts and assumptions
   4.3 Product structure type definitions
   4.4 Product structure entity definitions
   4.5 Product structure function definitions
5 Product concept
   5.1 General
   5.2 Fundamental concepts and assumptions
   5.3 Product concept entity definitions
6 Configuration management
   6.1 General
   6.2 Fundamental concepts and assumptions
   6.3 Configuration management type definitions
   6.4 Configuration management entity definitions

A Short names of entities
B Information object registration
C Computer interpretable listings
D EXPRESS-G diagrams
E Examples
F Change history
Bibliography
Index

(*
ISO/TC 184/SC 4/WG 12 N10967 - ISO 10303-44 Product structure configuration - EXPRESS
Supersedes ISO/TC 184/SC 4/WG 12 N10470
*)



SCHEMA product_structure_schema;

REFERENCE FROM measure_schema   -- ISO 10303-41
  (measure_with_unit);

REFERENCE FROM product_definition_schema   -- ISO 10303-41
  (acyclic_product_definition_relationship,
   generic_product_definition_reference,
   product,
   product_definition,
   product_definition_formation,
   product_definition_or_reference,
   product_definition_reference,
   product_definition_relationship,
   product_definition_relationship_relationship);

REFERENCE FROM support_resource_schema   -- ISO 10303-41
  (identifier,
   label,
   text);


TYPE product_definition_occurrence_or_reference = SELECT
   (product_definition_occurrence,
    product_definition_occurrence_reference);
END_TYPE;

TYPE product_definition_or_reference_or_occurrence = SELECT BASED_ON product_definition_or_reference WITH
   (product_definition_occurrence);
END_TYPE;

ENTITY alternate_product_relationship;
  name : label;
  definition : OPTIONAL text;
  alternate : product;
  base : product;
  basis : text;
UNIQUE
  UR1: alternate, base;
WHERE
  WR1: alternate :<>: base;
END_ENTITY;

ENTITY assembly_component_usage
  SUPERTYPE OF (quantified_assembly_component_usage
                ANDOR ONEOF (multi_level_reference_designator,
                     next_assembly_usage_occurrence,
                     promissory_usage_occurrence,
                     specified_higher_usage_occurrence))
  SUBTYPE OF (product_definition_usage);
  reference_designator : OPTIONAL identifier;
END_ENTITY;

ENTITY assembly_component_usage_substitute;
  name : label;
  definition : OPTIONAL text;
  base : assembly_component_usage;
  substitute : assembly_component_usage;
UNIQUE
  UR1: base, substitute;
WHERE
  WR1: base.relating_product_definition :=: substitute.relating_product_definition;
  WR2: base :<>: substitute;
END_ENTITY;

ENTITY assembly_component_usage_substitute_with_ranking
  SUBTYPE OF (assembly_component_usage_substitute);
  ranking : INTEGER;
  ranking_rationale : text;
END_ENTITY;

ENTITY make_from_usage_option
  SUBTYPE OF (product_definition_usage);
  ranking : INTEGER;
  ranking_rationale : text;
  quantity : measure_with_unit;
WHERE
  WR1: (NOT ('NUMBER' IN TYPEOF(quantity.value_component))) OR (quantity.value_component > 0);
END_ENTITY;

ENTITY make_from_usage_option_group;
  members : SET[2:?] OF make_from_usage_option;
WHERE
  WR1: SIZEOF(QUERY(example <* members | example.related_product_definition :=: members[1].related_product_definition)) = SIZEOF(members);
END_ENTITY;

ENTITY multi_level_reference_designator
  SUBTYPE OF (assembly_component_usage);
  location : LIST[1:?] OF UNIQUE next_assembly_usage_occurrence;
DERIVE
  SELF\product_definition_relationship.relating_product_definition RENAMED root : product_definition := location[1]\product_definition_relationship.relating_product_definition;
  SELF\product_definition_relationship.related_product_definition RENAMED leaf : product_definition_or_reference := location[HIINDEX(location)]\product_definition_relationship.related_product_definition;
UNIQUE
  UR1: location;
WHERE
  WR1: unambiguously_specified_multi_level_reference_designator(location);
  WR2: SIZEOF(QUERY(cp <* location | NOT (EXISTS(cp\assembly_component_usage.reference_designator)))) = 0;
END_ENTITY;

ENTITY next_assembly_usage_occurrence
  SUBTYPE OF (assembly_component_usage);
DERIVE
  product_definition_occurrence_id : identifier := SELF\product_definition_relationship.related_product_definition\product_definition_occurrence.id;
UNIQUE
  UR1: SELF\assembly_component_usage.reference_designator, SELF\product_definition_relationship.relating_product_definition;
  UR2: product_definition_occurrence_id, SELF\product_definition_relationship.relating_product_definition;
END_ENTITY;

ENTITY product_definition_occurrence
  SUPERTYPE OF (product_definition_specified_occurrence
                ANDOR product_definition_occurrence_reference_with_local_representation);
  id : identifier;
  name : OPTIONAL label;
  description : OPTIONAL text;
  definition : OPTIONAL product_definition_or_reference_or_occurrence;
  quantity : OPTIONAL measure_with_unit;
DERIVE
  descendant_occurrences : SET[0:?] OF product_definition_specified_occurrence := get_descendant_occurrences(SELF);
INVERSE
  assembly_usages : SET[0:?] OF assembly_component_usage FOR related_product_definition;
  child_occurrences : SET[0:?] OF product_definition_specified_occurrence FOR occurrence_usage;
WHERE
  WR1: NOT (('PRODUCT_STRUCTURE_SCHEMA.PRODUCT_DEFINITION_OCCURRENCE' IN TYPEOF(definition)) OR ('PRODUCT_STRUCTURE_SCHEMA.PRODUCT_DEFINITION_OCCURRENCE_REFERENCE' IN TYPEOF(definition))) OR ('PRODUCT_STRUCTURE_SCHEMA.PRODUCT_DEFINITION_SPECIFIED_OCCURRENCE' IN TYPEOF(SELF));
  WR2: EXISTS(definition) OR (SIZEOF(USEDIN(SELF, 'CONFIGURATION_MANAGEMENT_SCHEMA.CONFIGURATION_DESIGN.DESIGN')) > 0);
  WR3: NOT ('NUMBER' IN TYPEOF(quantity\measure_with_unit.value_component)) OR (quantity\measure_with_unit.value_component > 0);
END_ENTITY;

ENTITY product_definition_occurrence_reference
  SUBTYPE OF (product_definition_reference);
  product_occurrence_id : identifier;
END_ENTITY;

ENTITY product_definition_occurrence_reference_with_local_representation
  SUBTYPE OF (product_definition_occurrence, generic_product_definition_reference);
END_ENTITY;

ENTITY product_definition_occurrence_relationship;
  name : label;
  description : OPTIONAL text;
  occurrence : product_definition;
  occurrence_usage : assembly_component_usage;
WHERE
  WR1: occurrence_usage.relating_product_definition :<>: occurrence;
  WR2: occurrence_usage.related_product_definition :<>: occurrence;
  WR3: occurrence.formation :=: occurrence_usage.related_product_definition.formation;
END_ENTITY;

ENTITY product_definition_specified_occurrence
  SUBTYPE OF (product_definition_occurrence);
  SELF\product_definition_occurrence.definition : product_definition_occurrence_or_reference;
  occurrence_usage : product_definition_occurrence_or_reference;
UNIQUE
  UR1: occurrence_usage, id;
WHERE
  WR1: SIZEOF(assembly_usages) = 0;
  WR2: acyclic_product_definition_specified_occurrence(SELF, SELF\product_definition_occurrence.definition);
END_ENTITY;

ENTITY product_definition_usage
  SUPERTYPE OF (ONEOF (make_from_usage_option,
                       assembly_component_usage))
  SUBTYPE OF (product_definition_relationship);
UNIQUE
  UR1: SELF\product_definition_relationship.id, SELF\product_definition_relationship.relating_product_definition, SELF\product_definition_relationship.related_product_definition;
WHERE
  WR1: acyclic_product_definition_relationship(SELF, [SELF\product_definition_relationship.related_product_definition], 'PRODUCT_STRUCTURE_SCHEMA.PRODUCT_DEFINITION_USAGE');
END_ENTITY;

ENTITY product_definition_usage_relationship
  SUBTYPE OF (product_definition_relationship_relationship);
  SELF\product_definition_relationship_relationship.relating : product_definition_usage;
  SELF\product_definition_relationship_relationship.related : product_definition_usage;
WHERE
  WR1: relating.relating_product_definition :=: related.relating_product_definition;
END_ENTITY;

ENTITY promissory_usage_occurrence
  SUBTYPE OF (assembly_component_usage);
END_ENTITY;

ENTITY quantified_assembly_component_usage
  SUBTYPE OF (assembly_component_usage);
  quantity : measure_with_unit;
WHERE
  WR1: (NOT ('NUMBER' IN TYPEOF(quantity.value_component))) OR (quantity.value_component > 0);
END_ENTITY;

ENTITY specified_higher_usage_occurrence
  SUBTYPE OF (assembly_component_usage);
  upper_usage : assembly_component_usage;
  next_usage : next_assembly_usage_occurrence;
UNIQUE
  UR1: upper_usage, next_usage;
WHERE
  WR1: SELF :<>: upper_usage;
  WR2: SELF\product_definition_relationship.relating_product_definition :=: upper_usage.relating_product_definition;
  WR3: SELF\product_definition_relationship.related_product_definition :=: next_usage.related_product_definition;
  WR4: (upper_usage.related_product_definition :=: next_usage.relating_product_definition) OR (SIZEOF(QUERY(pdr <* USEDIN(upper_usage.related_product_definition, 'PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION') | pdr.relating_product_definition :=: next_usage.relating_product_definition)) = 1);
  WR5: SIZEOF(['PRODUCT_STRUCTURE_SCHEMA.NEXT_ASSEMBLY_USAGE_OCCURRENCE', 'PRODUCT_STRUCTURE_SCHEMA.SPECIFIED_HIGHER_USAGE_OCCURRENCE'] * TYPEOF(upper_usage)) = 1;
END_ENTITY;

FUNCTION acyclic_product_definition_specified_occurrence
 (pdso : product_definition_specified_occurrence; definition : product_definition_occurrence) : BOOLEAN;
    IF NOT (('PRODUCT_STRUCTURE_SCHEMA.PRODUCT_DEFINITION_SPECIFIED_OCCURRENCE') IN TYPEOF(definition))
  THEN
    RETURN(TRUE);
  END_IF;
      IF (definition :=: pdso)
  THEN
    RETURN(FALSE);
  ELSE
    RETURN(acyclic_product_definition_specified_occurrence(pdso, definition\product_definition_occurrence.definition));
  END_IF;
END_FUNCTION;

FUNCTION get_descendant_occurrences
 (input : product_definition_occurrence) : SET[0:?] OF product_definition_specified_occurrence;
  LOCAL
  result : SET OF product_definition_specified_occurrence := input.child_occurrences;
    END_LOCAL;
      REPEAT i := 1 TO HIINDEX(input.child_occurrences) BY 1;
    result := result + get_descendant_occurrences(input.child_occurrences[i]);
  END_REPEAT;
      RETURN(result);
END_FUNCTION;

FUNCTION unambiguously_specified_multi_level_reference_designator
 (links : LIST[1:?] OF next_assembly_usage_occurrence) : BOOLEAN;
    REPEAT i := 1 TO SIZEOF(links) - 1;
    CASE TRUE OF
      ('PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION' IN
       TYPEOF(links[i]\product_definition_relationship.relating_product_definition)) AND
      ('PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION' IN
       TYPEOF(links[i]\product_definition_relationship.related_product_definition)) AND
      ('PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION' IN
       TYPEOF(links[i + 1]\product_definition_relationship.relating_product_definition)) : BEGIN  
                                                                                                  IF NOT ((links[i]\product_definition_relationship.related_product_definition :=:
                                                                                                           links[i +
                                                                                                                 1]\product_definition_relationship.relating_product_definition) OR
                                                                                                          ((SIZEOF(QUERY(pdr
                                                                                                                         <* USEDIN(links[i]\product_definition_relationship.related_product_definition, 'PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION')
                                                                                                                         | pdr\product_definition_relationship.relating_product_definition :=:
                                                                                                                           links[i +
                                                                                                                                 1]\product_definition_relationship.relating_product_definition)) =
                                                                                                            1) AND
                                                                                                           (links[i]\product_definition_relationship.related_product_definition\product_definition.formation\product_definition_formation.of_product :=:
                                                                                                            links[i +
                                                                                                                  1]\product_definition_relationship.relating_product_definition\product_definition.formation\product_definition_formation.of_product)))
                                                                                                  THEN
                                                                                                    RETURN(FALSE);
                                                                                                  END_IF;
      END;
      ('PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION_REFERENCE' IN
       TYPEOF(links[i]\product_definition_relationship.related_product_definition)) AND
      ('PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION_REFERENCE' IN
       TYPEOF(links[i + 1]\product_definition_relationship.relating_product_definition)) : BEGIN  
                                                                                                  IF NOT ((links[i]\product_definition_relationship.related_product_definition :=:
                                                                                                           links[i +
                                                                                                                 1]\product_definition_relationship.relating_product_definition) OR
                                                                                                          ((SIZEOF(QUERY(pdr
                                                                                                                         <* USEDIN(links[i]\product_definition_relationship.related_product_definition, 'PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION')
                                                                                                                         | pdr\product_definition_relationship.relating_product_definition :=:
                                                                                                                           links[i +
                                                                                                                                 1]\product_definition_relationship.relating_product_definition)) =
                                                                                                            1) AND
                                                                                                           (links[i]\product_definition_relationship.related_product_definition\product_definition_reference.product_id =
                                                                                                            links[i +
                                                                                                                  1]\product_definition_relationship.relating_product_definition\product_definition_reference.product_id) AND
                                                                                                           (links[i]\product_definition_relationship.related_product_definition\product_definition_reference.id_owning_organization_name =
                                                                                                            links[i +
                                                                                                                  1]\product_definition_relationship.relating_product_definition\product_definition_reference.id_owning_organization_name) AND
                                                                                                           (links[i]\product_definition_relationship.related_product_definition\product_definition_reference.product_definition_id <>
                                                                                                            links[i +
                                                                                                                  1]\product_definition_relationship.relating_product_definition\product_definition_reference.product_definition_id)))
                                                                                                  THEN
                                                                                                    RETURN(FALSE);
                                                                                                  END_IF;
      END;
      ('PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION_REFERENCE' IN
       TYPEOF(links[i]\product_definition_relationship.relating_product_definition)) AND
      ('PRODUCT_DEFINITION_SCHEMA.PRODUCT_DEFINITION' IN
       TYPEOF(links[i]\product_definition_relationship.related_product_definition)) : RETURN(FALSE);
      OTHERWISE: RETURN(FALSE);
    END_CASE;
  END_REPEAT;
      RETURN(TRUE);
END_FUNCTION;

END_SCHEMA;  -- product_structure_schema


© ISO 2021 — All rights reserved