Business DEX overview

Resources are stocks or supplies or single items of materials or assets or persons that may be used or consumed in the carrying out of tasks and actions.

Relating tasks, methods, events, and activities to different resouce specifications

or in terms of an item that satisfies such a requirement (see below).

Categorizing different items as resources and relating those item to one another

Where a resource is specified in terms of a document, organization, person, product or other item that constitutes a resource in a particular context, such items may be types:

Information model overview

The EXPRESS-G for the representingresource
Error C1: Capability representingresource not in dex_index.xml
capability is shown in Figure 1 below and explained in the following sections.

NOTE 1   The EXPRESS-G is not complete. For the complete EXPRESS see the modules: Resource item and Required resource.

Figure 1 —  Representing resource EXPRESS-G

The resource item

A Resource_item is the fundamental unit of resource. A resource item can be one of the following (as defined in Ap239_task_specification_resourced):

• Document;
• Document_definition;
• Document_version;
• File;
• Location;
• Organization;
• Organization_type;
• Part;
• Part_version;
• Part_view_definition;
• Person*;
• Person_in_organization*;
• Position*;
• Position_type;
• Product_as_individual*;
• Product_group;
• Type_of_person.

NOTE 2   The list comprises two distinct datatype categories: types of things (unmarked) and tokens of things (marked *). In general, types are used when specifying resources, for example, when saying a task needs to use a crane, whereas tokens are used when recording history, for example, that a task used crane number 123. This is not, however, a hard and fast rule, and two exceptions occur when, for example:

1. A task is specified against a specific resource, such as "the naval dockyard in Portsmouth" on the basis of an assumption that particular facilities only available there;
2. It is not necessary to track which particular resource was used when a task was performed, such as the fact that task 1234 used a hammer on 20th December. Resource use like this would normally only be recorded if it were unusual.

The identification of a Resource_item is defined in the capability referencing_resource
Error C1: Capability referencing_resource not in dex_index.xml
. A Resource_item also has a name and an optional description. Resource_item may also be further characterized (see below).

An example instance diagram for Resource_item is shown in figure 5 below in the section on characterization.

NOTE 3   Resource_item is also referenced by the activity
Error C1: Capability activity not in dex_index.xml
, observation
Error C1: Capability observation not in dex_index.xml
, resource_management
Error C1: Capability resource_management not in dex_index.xml
, resource_as_realized
Error C1: Capability resource_as_realized not in dex_index.xml
, scheme_entry
Error C1: Capability scheme_entry not in dex_index.xml
, task
Error C1: Capability task not in dex_index.xml
and work_request
Error C1: Capability work_request not in dex_index.xml
capabilities, but these are uses of Resource_item rather than its characteristics.

Resource item relationships

Resource_item objects may be related to other Resource_items or to other items.

Relationships between Resource_items are defined using the typical STEP relationship pattern, with the role being defined by classification, rather than by means of an explicit attribute. There are no constraints on the network of relationships. The subtype of this relationship Resource_group_relationship, which covers relationships such as "a tool box contains a mallet" or "a compressor provides compressed air". That is, it is stronger than the general Resource_event_relationship in that it implies that all the particular resources should be considered, and perhaps managed, as a single unit.

The Resource_group_relationship optionally carries a quantity, used, for example, to describe the relation "the oil tank holds up to 2000l of unleaded petrol". An instance diagram for this is shown in figure 2.

Figure 2 —  Resource Group

The Resource_item_assignment allows a Resource_item to be related to:

• Contract;
• Location;
• Part;
• Part_version;
• Part_view_definition;
• Product_group; or
• Project.

NOTE 4   The role may not be "as resource item". In this relationship, potential roles for Part include "applicable to" or "purchased for". For example, baggage loading vehicle is applicable to Boeing 737. For further discussion of the meaning of this relationship, see below.

NOTE 5   Both Resource_item_assignment and Resource_item_relationship may be further characterized (see below).

Required resource

Tasks are specified by identifying the resources they require: such as tools, test equipment, cleaning rags, etc. The Required_resource construct provides three ways to identify these resources: by specification, by resource type, or by particular resource.

Required_resource_by_specification is the subtype of Required_resource that identifies the resource by stating the things the resource must have or must do, for example, a 115v 20kVA power supply. The basic facility for identifying the requirement is the description attribute of Required_resource. It is, however, possible to apply a requirement (strictly a Requirement_view_definition) by using a Requirement_assignment.

The definition of a resource in terms of a resource type or a particular item is established through use of the Required_resource_by_resource_item subtype . This subtype specifies the required resource by referencing a Resource_item. The resource is specified by the Resource_item, which references a type of item, such as a Part, or a Type_of_person; or references a token of an item, such as Product_as_individual or Person.

NOTE 6   A Required_resource can always be classified and may be further characterized (see below).

Relationships between pairs of Required_resource objects are established through use of the Required_resource_relationship. The role of the Required_resource_relationship is defined by means of classification. One important use of this relationship is to identify particular Resource_items that meet the specification of a Required_resource_by_specification.

NOTE 7   This mechanism identifies the items than may fulfil the specification, not the item actually used by the task. The item used by the task is identified by means of the ResourceasRealized
Error C1: Capability ResourceasRealized not in dex_index.xml
capability.

NOTE 8   A Required_resource_relationship can always be classified and may be further characterized (see below).

Figure 3 shows an instance diagram for the Required_resource area.

Figure 3 —  Required Resource

Required resource assignment

The problem considered here is: "What is the difference between assigning a Task_method to a Required_resource with Applied_activity_method_assignment, and assigning a Required_resource to a Task_method with Required_resource_assignment?". This is a fundamental issue concerning the interpretation of Applied_activity_method_assignment and Required_resource_assignment.

Essentially,

• if a resource is needed in the performance of a task, then Applied_activity_method_assignment is used in the role of "Required resource" and points to the appropriate subtype of Required_resource;
• if a task, as a side effect, affects a Resource_item, then Applied_activity_method_assignment is used in the role of "Affected resource" and points to Resource_item;
• if, in order to use a resource, it has to be prepared in some way, then the preparation task is specified by a Required_resource_assignment in the role of "Resource preparation";
• if, after the resource as been used in a task, some further task is needed either to dispose of the resource or to make it ready for the future, then this is done by Required_resource_assignment in the role of "Resource disposition";
• If the Resource_item has a relation to something outside of the context of a task, then the relationship is made through Required_resource_assignment.

For example, one of the tasks in servicing a passenger aircraft is to service the lavatories. This might require the use of (Applied_activity_method_assignment) a dedicated servicing vehicle (the Resource_item) designed for the aircraft type (a Resource_item_assignment to Product_group) . The vehicle must be filled beforehand (Required_resource_assignment) with water (a quantified, required resource linked by Required_resource_relationship) for the flush, and the sewage disposed of afterwards (Required_resource_assignment). An instance diagram for this is shown in figure 4.

Figure 4 —  Tasks and Resources

A Required_resource_assignment can be assigned to:

• Contract*;
• Location*;
• Part*;
• Part_version*;
• Part_view_definition*;
• Product_group*;
• Project*;
• Activity#;
• Activity_method#;
• Event#;
• Scheme#;
• Scheme_entry#.

* ap239_task_secification_resourced
Error C1: Capability ap239_task_secification_resourced not in dex_index.xml
; #ap239_work_definition
Error C1: Capability ap239_work_definition not in dex_index.xml
.

NOTE 9   A Required_resource_assignment can always be classified and may be further characterized (see below).

Required_resource_assignment is also used by Scheme_entry.

The roles identified above are defined through reference data. The set of roles required for the DEX are defined in the DEX. If finer grained relationships are required, it is recommended this is done by extending the reference data to include subtypes of the roles.

Characterization of representing resource

Most of the constructs shown in Figure 1 can be characterized; which is to say that they may have approvals, classifications, conditions, dates or times, identifiers, justifications, persons or organizations, or properties assigned to them. The following sections detail the characterization of resource objects.

Assigning approvals

Approvals of resources or of resource assignments are represented by the assignment of Approval objects to Required_resource, Required_resource_assignment, Required_resource_by_resource_item, Resource_item, and Resource_item_assignment objects using Approval_assignment objects.

NOTE 10   The assignment of approvals is described in the capability: C019: assigning_approvals.

An instance diagram showing the assignment of an approval to a Resource_item is given in Figure 5.

Assigning classifications

The classification of resources or of assignments of resources is represented by the assignment of External_class objects to Required_resource, Required_resource_assignment, Required_resource_by_resource_item, Resource_item, and Resource_item_assignment objects using Approval_assignment objects.

An instance diagram showing the assignment of a classification to an Resource_item is given in Figure 5.

Assigning conditions

The application of conditional statements to resources or assignments of resources is represented by the assignment of Condition objects to Required_resource, Required_resource_assignment, Required_resource_by_resource_item, Resource_item, and Resource_item_assignment objects using Condition_assignment objects.

Assigning dates and times

Start and end dates for the availability of resources or for the need-for resources are represented by the assignment of Date_time objects or Calendar_date objects to Required_resource, Required_resource_assignment, Required_resource_by_resource_item, Resource_item, and Resource_item_assignment objects using Date_or_date_time_assignment objects.

NOTE 11   The assignment of date and times is described in the capability: C036: assigning_date_time.

Assigning identifers

The identification of resources is achieved by the linking of Identification_assignment objects to Required_resource, Required_resource_by_resource_item, and Resource_item objects.

NOTE 12   The assignment of approvals is described in the capability: C001: assigning_identifiers.

An instance diagram showing the assignment of an identifer to an Resource_item is given in Figure 5.

Assigning justifications

Justifications for resources or assignments of resources are represented by the assignment of Justification objects to Required_resource, Required_resource_assignment, Required_resource_by_resource_item, Resource_item, and Resource_item_assignment objects using Justification_assignment objects.

Assigning locations

Locations of resources or of assignments of resources are represented by the assignment of Location objects to Required_resource, Required_resource_assignment, Required_resource_by_resource_item, Resource_item, and Resource_item_assignment objects using Location_assignment objects.

Assigning persons and organizations

The ownership or responsibility for resources or of assignments of resources is represented by the assignment of Organization and Person_in_organization objects to Required_resource, Required_resource_assignment, Required_resource_by_resource_item, Resource_item, and Resource_item_assignment objects using Organization_or_person_in_organization_assignment objects.

Assigning resource properties

The attachment of properties to resources is achieved by the linking of Resource_property objects to Required_resource, Required_resource_by_resource_item, and Resource_item. objects.

NOTE 13   The assignment of approvals is described in the capability: C078: assigning_resource_properties.

Figure 5 —  Resource as characterized

Capability templates

The following sections define a set of templates for the capability, where a template is a specification of a set of entities that need to be instantiated to represent a given set of information.

This section specifies the template assigning_required_resource.

NOTE  An explanation of a template and the associated instantiation path is provided in the Template overview section.

Figure 1 —  An EXPRESS-G representation of the Information model for assigning_required_resource

Figure 2 —  The graphical representation of the assigning_required_resource template

Figure 3 —  Entities instantiated by assigning_required_resource template

          #1 = RESOURCE_ITEM('/IGNORE','/IGNORE',$);
          #2 = TASK_METHOD_VERSION('/IGNORE','/IGNORE','/IGNORE','/IGNORE',$,$);
          #3 = REQUIRED_RESOURCE_BY_RESOURCE_ITEM('/IGNORE','/IGNORE',$,#1);
          #4 = REQUIRED_RESOURCE_ASSIGNMENT(#3,#2);
          #6 = CLASSIFICATION_ASSIGNMENT(#8,(#3),'/IGNORE');
          #8 = EXTERNAL_CLASS('/NULL','Consumable','/IGNORE',#9);
          #9 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:sample',$);
        

Figure 4 —  Instantiation of assigning_required_resource template

This section specifies the template representing_required_resource_relationship.

NOTE  An explanation of a template and the associated instantiation path is provided in the Template overview section.

Figure 1 —  An EXPRESS-G representation of the Information model for representing_required_resource_relationship

Figure 2 —  The graphical representation of the representing_required_resource_relationship template

Figure 3 —  Entities instantiated by representing_required_resource_relationship template

          #1 = REQUIRED_RESOURCE_BY_RESOURCE_ITEM('/IGNORE','/IGNORE',$,$);
          #2 = REQUIRED_RESOURCE_BY_RESOURCE_ITEM('/IGNORE','/IGNORE',$,$);
          #3 = REQUIRED_RESOURCE_RELATIONSHIP('/IGNORE','/IGNORE',#1,#2);
          #5 = CLASSIFICATION_ASSIGNMENT(#6,(#3),'/IGNORE');
          #6 = EXTERNAL_CLASS('/NULL','Alternative_resource','/IGNORE',#7);
          #7 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:sample','/IGNORE');
        

Figure 4 —  Instantiation of representing_required_resource_relationship template

This section specifies the template representing_resource_item.

NOTE  An explanation of a template and the associated instantiation path is provided in the Template overview section.

Figure 1 —  An EXPRESS-G representation of the information model for the template 'representing_resource_item'

Figure 2 —  Graphical representations for the template 'representing_resource_item'

Figure 3 —  Entities and templates used by the 'representing_resource_item' template

DATA;
#1 = PART('/IGNORE','/IGNORE','/IGNORE');
#2 = RESOURCE_ITEM('/IGNORE','/IGNORE',(#1));
#3 = IDENTIFICATION_ASSIGNMENT('PRUS-RI-001-001','/IGNORE',$,(#2));
#5 = CLASSIFICATION_ASSIGNMENT(#7,(#3),'/IGNORE');
#7 = EXTERNAL_CLASS('/NULL','Resource_item_identification_code','/IGNORE',#8);
#8 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:std',$);
#10 = ORGANIZATION('/IGNORE','/IGNORE');
#12 = IDENTIFICATION_ASSIGNMENT('Parts R Us Ltd','/IGNORE','/IGNORE',(#10));
#14 = CLASSIFICATION_ASSIGNMENT(#16,(#12),'/IGNORE');
#16 = EXTERNAL_CLASS('/NULL','Organization_name','/IGNORE',#8);
#18 = ORGANIZATION_OR_PERSON_IN_ORGANIZATION_ASSIGNMENT(#10,'/IGNORE',(#3));
#20 = CLASSIFICATION_ASSIGNMENT(#22,(#18),'/IGNORE');
#22 = EXTERNAL_CLASS('/NULL','Owner_of','/IGNORE',#8);
ENDSEC;
        

Figure 4 —  Invocation of the 'representing_resource_item' template - graphical presentation

This section specifies the template representing_resource_item_realization.

NOTE  An explanation of a template and the associated instantiation path is provided in the Template overview section.

Figure 1 —  An EXPRESS-G representation of the Information model for representing_resource_item_realization

Figure 2 —  The graphical representation of the representing_resource_item_realization template

Figure 3 —  Entities and templates used by representing_resource_item_realization template

#1 = RESOURCE_ITEM('/IGNORE','/IGNORE',(#25));
#3 = IDENTIFICATION_ASSIGNMENT('PRUS-RI-001-001','/IGNORE',$,(#1));
#5 = CLASSIFICATION_ASSIGNMENT(#7,(#3),'/IGNORE');
#7 = EXTERNAL_CLASS('/NULL','Resource_item_identification_code','/IGNORE',#8);
#8 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:std',$);
#10 = ORGANIZATION('/IGNORE','/IGNORE');
#12 = IDENTIFICATION_ASSIGNMENT('Parts R Us Ltd','/IGNORE','/IGNORE',(#10));
#14 = CLASSIFICATION_ASSIGNMENT(#16,(#12),'/IGNORE');
#16 = EXTERNAL_CLASS('/NULL','Organization_name','/IGNORE',#8);
#18 = ORGANIZATION_OR_PERSON_IN_ORGANIZATION_ASSIGNMENT(#10,'/IGNORE',(#3));
#20 = CLASSIFICATION_ASSIGNMENT(#22,(#18),'/IGNORE');
#22 = EXTERNAL_CLASS('/NULL','Owner_of','/IGNORE',#8);
#25 = PART('/IGNORE','/IGNORE','/IGNORE');
        

Figure 4 —  Instantiation of representing_resource_item_realization template

This section specifies the template representing_resource_item_relationship.

NOTE  An explanation of a template and the associated instantiation path is provided in the Template overview section.

Figure 1 —  An EXPRESS-G representation of the Information model for representing_resource_item_relationship

Figure 2 —  The graphical representation of the representing_resource_item_relationship template

Figure 3 —  Entities instantiated by representing_resource_item_relationship template

Figure 4 —  Instantiation of representing_resource_item_relationship template

Related capabilities

This capability "representing_resource" is related to the following capabilities:

• C078: assigning_resource_properties
• 
  Error C1: Capability referencing_resource not in dex_index.xml
  
• C005: representing_documents
• C027: representing_location
• C002: representing_parts
• C016: representing_person_organization
• C051: representing_person_organization_typical
• C045: representing_product_as_individual

Dependent capabilities

This capability "representing_resource" is dependent on the following capabilities:

• C001: assigning_identifiers

Model reference data

The following classes of reference data are required for this capability:

© OASIS 2010 — All rights reserved