|
|
Application module:
Packaged part black box model |
ISO/TS 10303-1710:2018-11(E)
© ISO
|
This clause specifies the information requirements for the
Packaged part black box model
application module. The information requirements are specified as the
Application Reference Model (ARM) of this application module.
NOTE 1 A graphical representation of the information
requirements is given in
Annex C.
NOTE 2 The mapping specification is specified in
5.1. It shows how
the information requirements are met by using common resources and
constructs defined or imported in the MIM schema of this application
module.
This clause defines the information requirements to which implementations shall
conform using the EXPRESS language as defined in ISO 10303-11.
The following begins the
Packaged_part_black_box_model_arm
schema and identifies the necessary external references.
EXPRESS specification:
*)
SCHEMA Packaged_part_black_box_model_arm;
(*
The following EXPRESS interface statements specify the elements
imported from the ARMs of other application modules.
EXPRESS specification:
*)
USE FROM
Functional_assignment_to_part_arm;
--
ISO/TS 10303-1674
USE FROM
Functional_usage_view_arm;
--
ISO/TS 10303-1705
USE FROM
Package_arm;
--
ISO/TS 10303-1707
USE FROM
Part_external_reference_arm;
--
ISO/TS 10303-1711
REFERENCE FROM
Support_resource_arm
--
ISO/TS 10303-1800
(bag_to_set);
(*
NOTE 1
The schemas referenced above are specified in the following
part of ISO 10303:
| Functional_assignment_to_part_arm |
ISO/TS 10303-1674 |
| Functional_usage_view_arm |
ISO/TS 10303-1705 |
| Package_arm |
ISO/TS 10303-1707 |
| Part_external_reference_arm |
ISO/TS 10303-1711 |
| Support_resource_arm |
ISO/TS 10303-1800 |
NOTE 2
See Annex C,
Figures
C.1and C.2
for a graphical representation of this schema.
This subclause specifies the ARM types
for this application module. The ARM types and
definitions are specified below.
The package_or_package_external_reference type allows for the designation of the data
types
Package, and Package_external_reference.
EXPRESS specification:
*)
TYPE
package_or_package_external_reference =
SELECT
(Package,
Package_external_reference);
END_TYPE;
(*
The ppbbm_material_item_select type is an extension
of the
material_item_select type.
It adds the data
type
Packaged_part
to the list of alternate data types.
EXPRESS specification:
*)
TYPE
ppbbm_material_item_select =
SELECT
BASED_ON
material_item_select
WITH
(Packaged_part);
END_TYPE;
(*
This subclause specifies the ARM entities for this
module. Each ARM application entity is an atomic element that
embodies a unique application concept and contains attributes
specifying the data elements of the entity. The ARM
entities and definitions are specified below.
A Packaged_part is a type of a
Part_usage_view.
A Packaged_part describes a part that exists independently from any particular assembly on which it may be used. The part usually has electrical
functionality and that domain is used in the notes but the
energy exchange domain between the part and its surroudings may be electrical, thermal, magnetic or photonic.
NOTE 1
The Packaged_part Application object does not indicate that a part is in a particular product class. Classification assignment can be used
to
classify the part a Packaged_part belongs to with the IEC 61360 component classification.
NOTE 2
An electrical part is sometimes realized by installing one or more occurrences of die into a container and creating a set
of terminals attached to the die
on the inside and available for external connections on the outside of the container. See
Figure 1
for an illustration of a cutaway view of an electrical component that includes terms related to the Packaged_part Application Object.
Figure 1 — Electrical part exploded assembly detail
NOTE 3
Two Packaged_part models may be exchanged with this part of ISO 10303, depending on usage.
One may support the exchange information that maps the functionality of the Electrical part to the
Bare_die,
or dies, included in the composition of the Packaged_part; and information that maps the terminals of those instances of
Bare_die to the terminals of the Packaged_part.
This mechanism provides maximum flexibility and information exchange and is characterized as a "white box" model.
This model is primarily included in the standard to support design to analysis activities.
Alternatively, one may map the functionality required directly to the Packaged_part terminals, and not populate the
Bare_die.
The alternative is simpler and is characterized as the "black box" model.
EXPRESS specification:
*)
ENTITY Packaged_part
SUBTYPE OF (Part_usage_view);
used_package : SET[1:?] OF package_or_package_external_reference;
implemented_function :
OPTIONAL
Functional_unit_usage_view;
DERIVE
potting_compound : SET[0:1] OF Material_identification := bag_to_set(QUERY( temp <* USEDIN(SELF,
'GENERIC_MATERIAL_ASPECTS_ARM.MATERIAL_IDENTIFICATION.ITEMS') |
(SIZEOF( QUERY( cla <* USEDIN(temp,'CLASSIFICATION_ASSIGNMENT_ARM.' +
'CLASSIFICATION_ASSIGNMENT.' + 'ITEMS') | cla.role = 'potting compound')) = 1)));
base_package : SET[1:?] OF Package := QUERY(up <* used_package |
(SIZEOF(['ALTERED_PACKAGE_ARM.ALTERED_PACKAGE',
'PART_EXTERNAL_REFERENCE_ARM.PACKAGE_EXTERNAL_REFERENCE'] * TYPEOF(up)) = 0)
);
INVERSE
access_mechanisms : SET[0:?] OF Packaged_part_terminal FOR associated_definition;
WHERE
WR1: NOT (EXISTS(implemented_function) XOR (SIZEOF(access_mechanisms) > 0));
WR2: SIZEOF(base_package) = 1;
WR3: single_package_product(base_package, used_package);
END_ENTITY;
(*
Attribute definitions:
used_package:
specifies the
package_or_package_external_reference
of the Packaged_part.
There shall be one or more used_package for a Packaged_part.
implemented_function:
specifies a role of the Functional_unit_usage_view for the Packaged_part. The function specified shall be that mapped by the functional view terminal to physical view terminal
allocation requirement. The value of this attribute need not be specified.
potting_compound:
specifies the Material_identification
that is used to support the enclosed Bare_die in the Packaged_part.
The value of this attribute need not be specified.
base_package:
specifies the members of used_package that are not
Altered_package
and that are not
Package_external_reference.
There shall be one or more base_package for a Packaged_part.
access_mechanisms:
an inverse relationship that specifies that the existence of the Packaged_part is dependent on the
existence of the Packaged_part_terminal that specifies the Packaged_part as its
associated_definition. There shall be zero or more Packaged_part_terminal for a Packaged_part.
Formal propositions:
WR1:
The function implemented shall exist if and only if the size of the access_mechanisms
is greater than zero and the size of the access_mechanisms shall be greater than zero if and only if the implemented_function exists.
WR2:
The size of base_package shall be exactly one.
WR3:
All packages referenced by Packaged_part that are not members of
Package_external_reference
shall be for the same member of
Product.
Informal propositions:
IP1:
The function implemented shall be the function whose terminals are mapped to the terminals of this Packaged_part.
IP2:
The combination of implemented_function\Product_view_definition.version and
used_package[1]\Product_view_definition.version shall be unique within a population of Packaged_part.
In the case where the Package_external_reference is used the combination shall be extended to include the
Package_external_reference.part_number string.
A Packaged_part_join_terminal is a type of Packaged_part_terminal such that an occurrence of the Packaged_part_terminal shall not be
in the role of an external interface when the occurrence of the associated Packaged_connector is a component
in an assembly.
EXPRESS specification:
*)
ENTITY Packaged_part_join_terminal
SUBTYPE OF (Packaged_part_terminal);
DERIVE
SELF\Part_terminal.interface_or_join_terminal : interface_or_join_terminal_enumeration := interface_or_join_terminal_enumeration.join_terminal;
END_ENTITY;
(*
Attribute definitions:
interface_or_join_terminal:
the terminal shall be a
join_terminal.
A Packaged_part_terminal is a type of Part_terminal that describes a terminal of
a Packaged_part.
EXPRESS specification:
*)
ENTITY Packaged_part_terminal
ABSTRACT SUPERTYPE
SUBTYPE OF (Part_terminal);
terminal_of_package : SET[1:?] OF Package_terminal;
SELF\Part_feature.associated_definition : Packaged_part;
WHERE
WR1: disjoint_package_terminals(terminal_of_package);
WR2: NOT EXISTS(SELF\Part_feature.precedent_feature);
END_ENTITY;
(*
Attribute definitions:
terminal_of_package:
specifies a role of the
Package_terminal
for the Packaged_part_terminal.
There shall be one or more
Package_terminal
for each terminal_of_package.
If there is more than one terminal_of_package then the member reference different
Package
members.
associated_definition:
an attribute inherited from the
Part_feature
shall be redeclared as the
Packaged_part
that has the Packaged_part_terminal.
Formal propositions:
WR1:
No
Package
shall be referenced by more than one member of terminal_of_package.
WR2:
The
precedent_feature
attribute inherited from
Part_feature
shall not exist.
This subclause specifies the ARM functions for
this module. The ARM functions and definitions are
specified below.
The function disjoint_package_terminals returns TRUE if the set of
Packages
that are referenced as
associated_definition
by members of input is the same size as the members of the set of
Package_terminal
in input.
EXPRESS specification:
*)
FUNCTION disjoint_package_terminals (input : SET[0:?] OF Package_terminal) : BOOLEAN;
LOCAL
pk : SET OF Package := []; -- get access to information base
END_LOCAL;
REPEAT i := 1 to HIINDEX( input);
pk := pk + input[i].associated_definition;
END_REPEAT;
RETURN(SIZEOF(input) = SIZEOF(pk));
END_FUNCTION;
(*
Argument definitions:
input:
the specified Package_terminal.
The function single_package_product returns TRUE if all the members of input reference the same member of
Product.
It returns False otherwise.
EXPRESS specification:
*)
FUNCTION single_package_product (input1 : SET[0:?] OF Package; input2 : SET[0:?] OF package_or_package_external_reference) : BOOLEAN;
RETURN(TRUE);
END_FUNCTION;
(*
Argument definitions:
input1:
the specified
Package.
input2:
the specified
package_or_package_external_reference.
*)
END_SCHEMA; -- Packaged_part_black_box_model_arm
(*
© ISO 2018 — All rights reserved
