representing_task

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

This template describes how to represent simple task specification. A task specification is a procedural description of how to do something. A simple task specification has a simple, unstructured definition, and may also identify the context in which it is used. More complex tasks are described in the various task capabilities, as it is not possible to reduce them to templates.

A task specification does not plan, schedule, or record what is done. This template is used to define the essential information for the specification, that is:

The task identifier and version;
Task life cycle status;
The task name and description;
Where applicable, the end-product that the task is specified against;
Where applicable, the affected product that the task is specified for;
A description of how the task is performed, either as a simple literal description or as a reference to an external document.

For example, task number 123 version 2 "Change Chain" may be specified for a 'Gears-r-us' type 3 Strumly-Bowman gear fitted to a 'Muddy-Badger' model 42 bicycle, and describes the steps needed to change the sprocket chain.

The template mandates only the minimum of information, and most of the information needed for a simple task is described under the characterization section.

This template is valid only for "in-use" stage of the Task specification life cycle, and does not consider the initial development phase, the obsolescence phase, development lifecycle data nor any controls on the development process or the authorizations that record that process. These are discussed in the C015: representing_task (NB Capabilities are not documented in this release of the PLCS standard)

For discussion of the meaning of identification and version and the parameters involved, see the template referencing_task. For a general approach to describing tasks, see C015: representing_task (NB Capabilities are not documented in this release of the PLCS standard) .

The template characterization describes a task specified as applying to a specific type of product (the affected product), that is one which can be identified by a part number, as opposed to against a general product configuration, or a task written against a specific individual, for example, as a repair for specific damage. Where the affected product is fitted to a higher level end product (e.g. the task describes how to maintain a particular type of pump when fitted in a given class of ship), the characterization also describes how to identify the higher level product. Other associations are described in the capability C090: representing_task_associations (NB Capabilities are not documented in this release of the PLCS standard) .

The template characterization allows for the task instructions to be held either as unstructured text or in a separate document. To structure the instructions into a system of task elements, see the capability C088: representing_task_structure (NB Capabilities are not documented in this release of the PLCS standard) .

The EXPRESS-G diagram in Figure 1 shows the templates and EXPRESS entities that are required to represent the template "representing_task_simple". The text highlighted in blue shows the template parameters.

Task_method and Task_method_version provide the control entities for the task, and are the homes of the summary information covering the task as a whole. Task_element describes how to perform the task. In a simple task, this may be either a simple description of what to do, or a reference to a more detailed document. In the latter case, Task_method can be used as a proxy to track the the lifecycle and usage of a task specification held in an external documentation system. The full TASK_CAPABILITY describes how to create structured tasks and associate properties, resources, etc to each step.

The model shows the three entities that must be instantiated.

The graphic for the template to be used in other EXPRESS-G diagrams is shown in Figure 2 below.

The diagram below shows the both the full and abbreviated templates for referencing task, and is followed by a detailed description of the input parameter

The task identifier, e.g. the task number.

The name of the class being used to classify the identifier being assigned to the task (i.e. the @task_id)

The identifier of the External_class_library storing the definition of the class referenced by the parameter @task_id_class_name.

The name or identifier of the Organization that owns the @task_id.

The name of the class being used to classify the identification of the Organization responsible for creating the @task_id.

The identifier of the External_class_library storing the definition of the class referenced by the parameter @task_org_id_class_name.

The task version identifier, for example, the sequence number of the version.

The name of the class being used to classify the task version identifier (@tesk_ver_id) assigned to Task_method_version.

The identifier of the External_class_library storing the definition of the class referenced by the parameter @task_ver_id_class_name.

The name or identifier of the organization that owns the task version identifier.

The name of the class being used to classify the identification of the Organization responsible for creating the @task_ver_id.

The identifier of the External_class_library storing the definition of the class referenced by the parameter @task_ver_org_id_class_name.

The name of the class being used to classify the task name assigned to Task_method_version.

The identifier of the External_class_library storing the definition of the class referenced by the parameter @task_name_class_name.

The name or identifier of the organization that owns the task name.

The name of the class being used to classify the identification of the Organization responsible for creating the @task_name.

The identifier of the External_class_library storing the definition of the class referenced by the parameter @task_name_org_id_class_name.

The detailed description of how the to perform the task.

Allow the Task_method entity instantiated in this path to be referenced when this template is used.

Note: The Task_method entity can be referenced in a template path by:

%^target = $representing_task_simple.task_method%

where target is the parameter to which the Task_method is bound.

The Task_method carries the identity of the task. Definitional elements can only be added in the initial development phase of the task. Most information is associated to the Task_method_version.

Allow the Task_method_version entity instantiated in this path to be referenced when this template is used.

Note: The Task_method_version entity can be referenced in a template path by:

%^target = $representing_task_simple.task_method_version%

where target is the parameter to which the Task_method_version is bound.

The Task_method_version provides the version control locus for task definition data. In the context of this template, this means changes to the details of how to perform a task, or of the parts the task is associated to.

Allow the Task_step entity instantiated in this path to be referenced when this template is used.

Note: The Task_step entity can be referenced in a template path by:

%^target = $representing_task_simple.task_step%

where target is the parameter to which the Task_step is bound.

The Task_element contains the details of how the task is to be performed.

Task_method
%^task_method = Task_method%
Task_method.name = '/IGNORE'
Task_method.description = '/IGNORE'
Task_method.consequence = '/IGNORE'
Task_method.purpose = '/IGNORE'

-- Identify the Task_method
/assigning_identification(
    items= ^task_method,
    id= @task_id,
    id_class_name= @task_id_class_name,
    id_ecl_id= @task_id_ecl_id,
    org_id= @task_org_id,
    org_id_class_name= @task_org_id_class_name,
    org_id_ecl_id= @task_org_id_ecl_id )/

-- Assign the task name to Task_method
/assigning_identification(
    items= ^task_method,
    id= @task_name,
    id_class_name= @task_name_class_name,
    id_ecl_id= @task_name_ecl_id,
    org_id= @task_name_org_id,
    org_id_class_name= @task_name_org_id_class_name,
    org_id_ecl_id= @task_name_org_id_ecl_id )/

-- Task method version
Task_method_version
%^task_method_version = Task_method_version%
Task_method_version.name = '/IGNORE'
Task_method_version.description = '/IGNORE'
Task_method_version.consequence = '/IGNORE'
Task_method_version.purpose = '/IGNORE'

-- Identify the Task_method_version as version
/assigning_identification(
    items= ^task_method_version,
    id= @task_ver_id,
    id_class_name= @task_ver_id_class_name,
    id_ecl_id= @task_ver_id_ecl_id,
    org_id= @task_ver_org_id,
    org_id_class_name= @task_ver_org_id_class_name,
    org_id_ecl_id= @task_ver_org_id_ecl_id )/

-- Task step
Task_step
%^task_step = Task_step%
Task_step.name = '/IGNORE'
Task_step.description = '/IGNORE'
Task_step.consequence = '/IGNORE'
Task_step.purpose = '/IGNORE'
/assigning_descriptor(
    descr= @task_details,
    class_name= 'Description',
    ecl_id= 'urn:plcs:rdl:std',
    is_assigned_to= ^task_step)/

The instance diagram in Figure 3 shows an example of the EXPRESS entities and templates that are instantiated by the template:

/representing_task_simple(task_id='BK123', task_id_class_name='task_method_identification_code', task_ecl_id='urn:plcs:rdl:std', task_org_id='Fix-a-bike Inc', task_org_id_class_name='Organization_name', task_org_id_ecl_id='urn:plcs:rdl:std', task_ver_id='3', task_ver_id_class_name='task_method_version_identification_code', task_ver_ecl_id='urn:plcs:rdl:std', task_ver_org_id='Fix-a-bike Inc', task_ver_org_id_class_name='Organization_name', task_ver_org_id_ecl_id='urn:plcs:rdl:std', task_name='Replace chain', task_details='Remove connector pin, ....')/

(an illustration of the consolidated representing_task_simple template is shown in Figure 4 below.)

The example shows an instance of a task - task BK123 version 3 - to change the sprocket chain on a bicycle.

The instance model in STEP ASCII exchange file format (ISO 10303 Part 21 syntax) is:


#14 = IDENTIFICATION_ASSIGNMENT('Fix-a-bike Inc','/IGNORE','/IGNORE',(#12));
#12 = ORGANIZATION('/IGNORE','/IGNORE');
#9 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:sample','/IGNORE');
#8 = EXTERNAL_CLASS('/NULL','task_method_identification_code','/IGNORE',#9);
#7 = CLASSIFICATION_ASSIGNMENT(#8,(#5),'/IGNORE');
#5 = IDENTIFICATION_ASSIGNMENT('BK123','/IGNORE','/IGNORE',(#1));
#3 = TASK_STEP('/IGNORE','/IGNORE','/IGNORE','/IGNORE',$);
#2 = TASK_METHOD_VERSION('/IGNORE','/IGNORE','/IGNORE','/IGNORE',#3,#1);
#1 = TASK_METHOD('/IGNORE','/IGNORE','/IGNORE','/IGNORE',());
#30 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:sample','/IGNORE');
#29 = EXTERNAL_CLASS('/NULL','Version_identification_code','/IGNORE',#30);
#28 = CLASSIFICATION_ASSIGNMENT(#29,(#26),'/IGNORE');
#26 = IDENTIFICATION_ASSIGNMENT('3','/IGNORE','/IGNORE',(#2));
#24 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:std','/IGNORE');
#23 = EXTERNAL_CLASS('/NULL','Owner_of','/IGNORE',#24);
#22 = CLASSIFICATION_ASSIGNMENT(#23,(#20),'/IGNORE');
#20 = ORGANIZATION_OR_PERSON_IN_ORGANIZATION_ASSIGNMENT(#19,'/IGNORE',(#5));
#19 = ORGANIZATION($,$);
#18 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:sample','/IGNORE');
#17 = EXTERNAL_CLASS('/NULL','Organization_name','/IGNORE',#18);
#16 = CLASSIFICATION_ASSIGNMENT(#17,(#14),'/IGNORE');
#47 = IDENTIFICATION_ASSIGNMENT('Replace chain','/IGNORE','/IGNORE',(#2));
#45 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:std','/IGNORE');
#44 = EXTERNAL_CLASS('/NULL','Owner_of','/IGNORE',#45);
#43 = CLASSIFICATION_ASSIGNMENT(#44,(#41),'/IGNORE');
#41 = ORGANIZATION_OR_PERSON_IN_ORGANIZATION_ASSIGNMENT(#40,'/IGNORE',(#26));
#40 = ORGANIZATION($,$);
#39 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:sample','/IGNORE');
#38 = EXTERNAL_CLASS('/NULL','Organization_name','/IGNORE',#39);
#37 = CLASSIFICATION_ASSIGNMENT(#38,(#35),'/IGNORE');
#35 = IDENTIFICATION_ASSIGNMENT('Fix-a-bike Inc','/IGNORE','/IGNORE',(#33));
#33 = ORGANIZATION('/IGNORE','/IGNORE');
#62 = ORGANIZATION_OR_PERSON_IN_ORGANIZATION_ASSIGNMENT(#61,'/IGNORE',(#47));
#61 = ORGANIZATION($,$);
#60 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:sample','/IGNORE');
#59 = EXTERNAL_CLASS('/NULL','Task_name','/IGNORE',#60);
#58 = CLASSIFICATION_ASSIGNMENT(#59,(#56),'/IGNORE');
#56 = IDENTIFICATION_ASSIGNMENT('Fix-a-bike Inc','/IGNORE','/IGNORE',(#54));
#54 = ORGANIZATION('/IGNORE','/IGNORE');
#51 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:sample','/IGNORE');
#50 = EXTERNAL_CLASS('/NULL','Task_method_version_name','/IGNORE',#51);
#49 = CLASSIFICATION_ASSIGNMENT(#50,(#47),'/IGNORE');
#77 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:std','/IGNORE');
#76 = EXTERNAL_CLASS('/NULL','Descriptor','/IGNORE',#77);
#75 = CLASSIFICATION_ASSIGNMENT(#76,(#73),'/IGNORE');
#73 = DOCUMENT('/IGNORE','/IGNORE','Break chain at removable link...');
#72 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:sample','/IGNORE');
#71 = EXTERNAL_CLASS('/NULL','Description','/IGNORE',#72);
#70 = CLASSIFICATION_ASSIGNMENT(#71,(#68),'/IGNORE');
#68 = DOCUMENT_ASSIGNMENT(#73,#3,'/IGNORE');
#66 = EXTERNAL_CLASS_LIBRARY('urn:plcs:rdl:std','/IGNORE');
#65 = EXTERNAL_CLASS('/NULL','Owner_of','/IGNORE',#66);
#64 = CLASSIFICATION_ASSIGNMENT(#65,(#62),'/IGNORE');

The instance model in STEP XML exchange file format (ISO 10303 Part 28 ed.2 syntax) is:

The instance diagram in Figure 4 shows the graphic symbol for the template that is to be used in other instance diagrams. The example template is:

The EXPRESS-G diagram in Figure 5 shows the possible characterizations of the template "representing_task_simple".

The following characterizations may apply:

Characterization Assigning End Product

NOTE this characterization is optional.

The assignment of a Part in the role of Task_end_product indicates that the task is designed to be used in conjunction with the end product. The assignment of multiple end products indicates that the task is designed for use with any of the end products.

NOTE 1 Assigning a task to an end product without assigning it to an end product is most appropriate for general tasks, such as external cleaning, or tasks, such as refueling, where there it is not useful to identify an end product.

NOTE 2 In some systems, the task identifier is not in itself unique, and the unique key is the combination of task number and end product.

NOTE 3 The terms end product and affected product refer to the overall system and to the system component respectively. For example, for the end product bicycle MB42-801, the affected product may be the gear hub SA3-401.

Characterization Assigning Affected Product

NOTE this characterization is optional.

The assignment of a Part in the role of Task_affected_product indicates that the task is designed for use on the affected part. The assignment of multiple affected products indicates that the task is designed for use with any of the affected products.

NOTE 1 Assigning multiple end-products and multiple affected items indicates that the task is appropriate for any combination of end-product and affected product. Restricting a task to certain pairwise combinations of end-product and affected product is beyond the scope of this template.

NOTE 2 Assigning an affected product without assigning an end product indicates that the task is valid for the affected product whatever the end-product. An example of this is changing a tyre, which may be the same for every wheel of a given design, whatever bicycle it is fitted to.

Characterization Assigning Describing Document

NOTE this characterization is optional.

A Describing Document is a document detailing the Task_step, and is used whenever the description is held in an external document.

NOTE This characterization is included to support existing paper or file based documentation systems, so that the existing documentation can be used without importing it into a PLCS system.

EXAMPLE 1 Figure 6 shows an instantiation diagram where the task BK 123 version 3 is applied to the end product MB42-801, where the affected item is the gear hub SA3-401, and the instructions are given in a separate document (not instantiated).

Figure 6 — Example characterization

Entity in path	Value	Inherited from
Task_method.name	'/IGNORE'	Activity_method.name
Task_method.description	'/IGNORE'	Activity_method.description
Task_method.consequence	'/IGNORE'	Activity_method.consequence
Task_method.purpose	'/IGNORE'	Activity_method.purpose
Task_method_version.name	'/IGNORE'	Activity_method.name
Task_method_version.description	'/IGNORE'	Activity_method.description
Task_method_version.consequence	'/IGNORE'	Activity_method.consequence
Task_method_version.purpose	'/IGNORE'	Activity_method.purpose
Task_step.name	'/IGNORE'	Activity_method.name
Task_step.description	'/IGNORE'	Activity_method.description
Task_step.consequence	'/IGNORE'	Activity_method.consequence
Task_step.purpose	'/IGNORE'	Activity_method.purpose