| Template:— representing_task_simple (rep_task_simple) |
Date: 2009/06/09 08:10:58
Revision: 1.12
|
This section specifies the template representing_task_simple.
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.
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;
- 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.
For discussion of the meaning of identification and version and the parameters involved, see the template referencing_task.
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.
The template characterization allows for the task instructions to be held either as unstructured text or in a separate document.
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 model shows the three entities that must be instantiated.
Figure 1 — An EXPRESS-G representation of the Information model for representing_task_simple
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
Figure 2 — The graphical representation of the representing_task_simple template
The following input parameters are defined for this template:
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 following classes and their sub-classes can be used:
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 following classes and their sub-classes can be used:
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 following classes and their sub-classes can be used:
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 following classes and their sub-classes can be used:
The identifier of the
External_class_library storing the
definition of the class referenced by the parameter @task_ver_org_id_class_name.
The textual identifier of the task.
The following classes and their sub-classes can be used:
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 following classes and their sub-classes can be used:
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 to perform the task.
The following reference parameters are defined for this template:
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.
%^target = $representing_task_simple.task_method_version%
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.
The following parameter combinations specify a uniqueness constraint:
Unique constraint: Unique task
Unique constraint: Unique task version
Each instance of the
entity
(
Task_method_version)
within the data set shall be uniquely identified
by a combination of the following parameters on this
template (representing_task_simple) namely:
task_id,
task_id_class_name,
task_id_ecl_id,
task_org_id,
task_org_id_class_name,
task_org_id_ecl_id,
task_ver_id,
task_ver_id_class_name,
task_ver_id_ecl_id,
task_ver_org_id,
task_ver_org_id_class_name,
task_ver_org_id_ecl_id.
The
instance is
referenced by the following template parameter:
task_method_version.
The instantiation path shown below specifies the entities that are to be
instantiated by the template.
A description of templates and the syntax for the instantiation path is
provided in the
Templates Help/Information section.
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'
Task_method_version.of_task_method ->
^task_method
-- 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'
-- Assign Task description /
assigning_descriptor(
descr=@task_details,
class_name='Description',
ecl_id='urn:plcs:rdl:std',
is_assigned_to=^task_step)/
-- Assign the ^task_step as the content of the ^task_method_version Task_method_version.content ->
^task_step
The following entities are instantiated with attributes as specified:
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='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_name_id_class_name='Task_method_name', task_name_ecl_id='urn:plcs:rdl:std', task_name_org_id='Fix-a-bike Inc', task_name_org_id_class_name='Organization_name', task_name_org_id_ecl_id='urn:plcs:rdl:std', task_details='Break chain at removable link...')/
(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.
Figure 3 — Entities instantiated by representing_task_simple template
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:
/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='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_name_id_class_name='Task_method_name', task_name_ecl_id='urn:plcs:rdl:std', task_name_org_id='Fix-a-bike Inc', task_name_org_id_class_name='Organization_name', task_name_org_id_ecl_id='urn:plcs:rdl:std', task_details='Break chain at removable link...')/
Figure 4 — Instantiation of representing_task_simple template
Characterizations
No common characterizations of the template
representing_task_simple
have been identified. However, the ISO 10303-239 EXPRESS model
may enable other assignments to the entities instantiated by the template.
