Académique Documents
Professionnel Documents
Culture Documents
SEMATECH
Technology Transfer 93061697J-ENG
SEMATECH and the SEMATECH logo are registered service marks of SEMATECH, Inc.
Product names and company names used in this publication are for identification purposes only and may be trademarks or service
marks of their respective companies.
Abstract: This document is version 2.0 of the Computer Integrated Manufacturing (CIM) Framework
Specification, containing updates and corrections to version 1.5. The purpose of the CIM
Framework is to assist in the creation of an integrated, common, flexible, modular object model
leading to an open, multi-supplier CIM system environment. It is designed to provide benefits that
include increased productivity, reduction in new development cost and cycle time, shorter factory
start-up and ramp-up times, a wider base of applications suppliers, and reduction in system mean
time to repair (MTTR). The document is designed for technical managers and staff, application
developers, and CIM Framework component suppliers.
Keywords: CIM, Frameworks, Interoperability Standards, Manufacturing Execution Systems, Object Oriented
Systems, Specifications, Software Reuse
Table of Contents
APPENDIX A Glossary.........................................................................................................................................329
APPENDIX B Acronyms ......................................................................................................................................335
APPENDIX C References .....................................................................................................................................337
APPENDIX D CIM Framework Events ................................................................................................................339
APPENDIX E Scenario Examples ........................................................................................................................373
E.1 Factory Operations Scenario.....................................................................................................................381
E.2 Product Request Scenario .........................................................................................................................382
List of Figures
List of Tables
Acknowledgements
The editor recognizes the efforts of the people, past and present, who have worked to develop the
CIM Framework Architecture and Specification documents since1991. The continued efforts by
the supporting companies, and more importantly the dedicated individuals from those companies,
has resulted in a CIM-based architecture for MES that has wide recognition in the industry. The
following is a list of SEMATECH personnel and member company assignees who contributed to
the CIM Framework over the years:
SEMATECH: AMD: AT&T: Digital:
Dale Blackwell Terry Bush Frank Yeager Prabhat Deosthali
Jim Hollister Tony Mullins
Carla Jobe Partington
Margaret Pratt
Fred Waskiewicz
Alan Weber
Texas Instruments:
Marv Aardal
Lawrence Eng
Bob Hodges
Glenn Hollowell
David Richardson
The efforts of individuals too numerous to list—at member company home locations, supplier
companies, academic and government facilities—in developing the CIM Framework are also
deeply appreciated.
Thank you!
1 EXECUTIVE SUMMARY
This document is a detailed specification of an application framework for the computer
integrated manufacturing (CIM) systems used in semiconductor factories. A framework is a
software infrastructure that creates a common environment for integrating applications and
sharing information in a given domain. The purpose of this framework is to establish an industry
standard architecture for these complex manufacturing systems, leading to an open, multisupplier
CIM system environment. The framework described in this specification is called the CIM
Framework.
Because of the ever-increasing complexity of semiconductor devices and manufacturing
processing, the production and process control capabilities provided by CIM systems are
essential for the smooth management of semiconductor factories. However, today’s CIM systems
generally are large, monolithic, and difficult to enhance or extend, having evolved over many
years to support the particular needs of an individual company or factory. This results in high
support costs and long delays to add new functionality, which in turn leads to low manufacturing
customer satisfaction and low development/support staff morale.
The CIM Framework defined by this specification addresses many of these problems and charts a
path to the next generation of semiconductor manufacturing systems software by the following:
• Providing a reusable, integrated system design that clearly specifies the functional scope,
interface boundaries, and standard information model of the required components of
semiconductor manufacturing systems
• Identifying CIM functionality common to all semiconductor manufacturing
• Basing implementation on advanced but proven open software technologies and standards
Significant industry adoption will provide manufacturing end users with a number of benefits.
These include increased programmer productivity, reduced cost and cycle time for new
application development, shorter times for initial factory start-up and ramp-up to production
yields, and finally, a wider base of manufacturing applications suppliers from which to choose.
This document is designed to meet very specific needs of four principal audiences within a
manufacturing systems organization: technical managers, system architects and engineers,
application software developers and integrators, and standards developers. Moreover, they may
be found in a variety of companies: semiconductor manufacturers, software product suppliers,
system integrators, research consortia, and equipment suppliers, to name a few.
To support this breadth of potential customers, the document is organized in the following major
sections.
Section Purpose
1, 2 An introduction appropriate to all audiences.
2 How the CIM Framework relates to and uses the Object Management Architecture (OMA). A
summary of notation used in the specification.
3 CIM Framework use of Job concepts that cross functional boundaries.
4 CIM Framework detailed design information, including interface definitions.
Appendixes Glossary, acronyms, references, events.
The CIM Framework Specification must continue to evolve to meet the needs of a competitive
and vital industry. The contents of this version represents a significant amount of real
development experience from a number of commercial software suppliers and their customers,
and parts of it reflect the product architectures of those companies.
The role of SEMATECH in the continued development of the CIM Framework will diminish as
of this release. The continued evolution of the CIM Framework will be carried on through
industry efforts such as MES product development and installation, and work in various industry
organizations (e.g., SEMI, Object Management Group [OMG], etc.).
Technical assistance for users of this document is available from:
Framework.Request.Information@sematech.org.
2 INTRODUCTION
The CIM Framework was created by SEMATECH to benefit its members and the overall
industry in the following ways:
• Reduce new Manufacturing Execution System (MES) application
development/integration cost and cycle time through adoption of a pre-designed
and pre-integrated system architecture.
• Reduce new factory ramp-up time because of faster equipment and factory
integration (e.g., make data collection and analysis tools available without
integration delays).
• Provide a stronger, broader base of viable application suppliers (especially
innovative, niche-oriented companies).
• Increase productivity of member company CIM system support teams because the
software is easier to fix and enhance (with limited side effects).
The CIM Framework defines a framework of components that provide the functionality common
across CIM applications and enables integration of those applications. The framework of
components does not, by itself, provide all the functionality of an integrated CIM system.
Framework components are designed to be specialized and extended with additional functions
and behaviors added (as additional application objects) to provide the specific functionality
needed for a given CIM product or solution. The CIM Framework specifies only those portions
of a CIM system necessary for standard application integration. It leaves the rest of the system
unspecified so suppliers and users have the flexibility to address product-specific and site-
specific needs.
The heart of the framework is a set of semiconductor manufacturing abstractions (e.g., Wafer,
Process Specification, Machine) and services (e.g., get wafer location, set specification
parameter, get machine utilization) that are typically embodied in applications (e.g., material
management, specification management, machine control) and delivered on distributed computer
platforms (e.g., workstations, servers) that use standard software system technologies (e.g.,
communications, database, user interface). The current CIM Framework is specifically targeted at
manufacturing information management and control for both the planning and operational phases
of semiconductor wafer fabrication.
Much of this specification may also be applicable to other manufacturing environments, such as
silicon die packaging and printed wiring board assembly. Related activities targeting these
environments will provide the basis for future convergence of the common aspects of MES
framework specifications.
This introductory section provides a description of the intended audience, a discussion of the
rationale for and benefits of CIM Framework use, guidance on the use of this document, an
overview of the CIM Framework functional scope, and a brief explanation of the graphical and
textual notations used to specify the framework.
The most important of these principles, abstraction, involves modeling an application domain
(e.g., semiconductor manufacturing) as a set of object abstractions (e.g., Product) with
well-defined service interfaces (e.g., continueProcessing), and encapsulated state and behavior.
Objects provide a higher, more understandable, and more stable level of abstraction than
traditional data and procedural abstractions. The principle of encapsulation hides the
implementation details of an object, which makes it easier to change while minimizing the
impact of change on the rest of the system. Inheritance and polymorphism are additional
object-oriented concepts that enable the generation of reusable software components. A detailed
description of the object-oriented approach to software development is beyond the scope of this
specification, but numerous excellent references are available in any bookstore with a computer
science section.
Object technology is becoming pervasive in all aspects of software engineering from analysis and
design methods to programming languages and user interfaces. Significant improvements in
software development productivity, quality, and maintenance have been reported from many
users and projects using the technology.
Recently, a more advanced object-oriented architectural concept called a framework has
emerged. Frameworks facilitate the coordinated reuse of large collections of related objects. The
net effect is to amplify the benefits obtained at the object level by expanding them to the module,
application, and system level. Frameworks provide even higher levels of abstraction (collections
of object abstractions), encapsulation (of whole sets of objects), and reuse (of whole object
mechanisms) than objects in and of themselves. The availability of a powerful new approach to
software engineering, coupled with the simultaneous occurrence of several major shifts in
manufacturing and computer science, provides an unparalleled opportunity for dramatic
improvement in all aspects of semiconductor CIM. The goal of the CIM Framework is to seize
this opportunity by creating a common, modular, flexible, integrated object model that unifies
these new concepts in an open, multi-supplier CIM system environment.
Benefits for the applications programmer and system engineer are as follows:
• The opportunity to focus on new application functionality
• No more need to “reinvent the wheel”
• The ability to focus on assembly of components
Multiple levels of packaging framework functionality are supported by the specification so that a
variety of applications from multiple suppliers with potentially intersecting capabilities can be
accommodated. This means that, given a specific framework binding to a set of computer and
software system technologies, an application can be instantiated and executed in this
environment and will register itself as a set of well known objects that provide a core set of
framework specified services.
Relationship
Component A Component B
RELATIONSHIP
NAME
ENTITY ENTITY
NAME 2 NAME
EXACTLY
TWO DATA-CARRYING
ONE RELATIONSHIP
ZERO OR
ONE
ASSOCIATION ENTITY
SUBTYPE NAME NAME
RELATIONSHIP
ZERO OR
MANY
PART-WHOLE
RELATIONSHIP
COMPONENT COMPONENT
ENTITY ENTITY
NAME NAME
The following example (Figure 3) of an Interaction Diagram models a portion of the interaction
between a bank customer and an Automated Teller Machine (ATM).
BankCustomer ATM
2. requestIdentification();
3. provideIdentification
in string idNumber ():
4. verifyIdentification ():
.
.
.
.
STATE
STATE1 STATE2 C
NAME
state
transition
concurrent states default entry point conditional selector
To illustrate use of Harel state charts, consider the Figure 5 example for an automobile:
start turn on lights
engine stopped engine running engine running
AND lights off AND lights off AND lights on
A more general Harel state chart showing hierarchy and concurrency for automobile states is
shown in Figure 6.
In Figure 6, the OPERATING parent state is divided into two concurrent substates, which in turn
represent a further breakdown into exclusive OR logical conditions (e.g., the engine can be in the
ENGINE RUNNING state) or (exclusive or) be in the ENGINE STOPPED state.
OPERATING
ENGINE LIGHTS
STOPPED OFF
1 2 3 4
ENGINE LIGHTS
RUNNING ON
Note that when an automobile engine is started a large number of internal state changes take
place in the system, most of which are encapsulated from the driver. Only externally visible
states and triggers have been presented.
Within the CIM Framework specification, only those triggers and state changes relevant to
external interfacing are shown to help define how an external entity (in this case, a driver)
interoperates with an object (in this example, an automobile).
While this table defines triggers for state transitions, there is no guarantee that the transition will
take place in response to the trigger. In the above example, if the car is out of gas the engine will
not go to the running state. If the light is burned out, it will not transition to the on state.
Depressing the accelerator pedal when the auto is in the off state will have no effect, etc. In the
CIM Framework, object state should be queried to ensure successful transitioning in response to
a triggering message.
The following conventions are used throughout this specification when defining exceptions:
• Εxceptions are not reserved for system or programming errors or failures but
should be included for any non-nominal application behavior in the called service.
This is consistent with CORBA usage of exceptions for application errors.
• Return values will, if necessary, be implemented as data in the exception
definition.
• All state transition services (makeXXX services) must include the
InvalidStateTransitionSignal exception in their list of raised exceptions.
• Services that perform a “find” or “lookup” function will raise an appropriate
<ObjectType>NotFoundSignal exception: a null return value is not an appropriate
response. However, services that return a collection of objects will not raise an
exception but will simply return an empty collection.
• Services that perform “add” functions will raise a <ObjectType>DuplicateSignal
exception for the case where the object to be added is already in the target
collection or logical set. The exception will include a field containing a reference
to the currently existing object.
• Services that perform “remove” functions will raise a
<ObjectType>NotAssignedSignal exception for the case when the given object
was not in the collection it was to be removed from or
<ObjectType>RemovalFailedSignal exception if the object could not be removed.
• Boolean query services should rarely raise an exception unless conditions are such
that neither a true or false return value can be determined.
Events:
The names of published events are listed in each interface and detailed in the appendix. The CIM
Framework Architecture Guide [CIMArch] contains information on how to use and build events.
Attributes:
Defining an IDL attribute requires the methods “get” and “set” to be applied to an object's
instance variable. Attributes may be qualified as readonly, meaning that an external entity has
only read privileges. In this case, only a get method is specified.
Sequences:
Throughout this specification, the keyword sequence denotes all container-type constructs
(collections, arrays, sets, etc.) Sequences are specified within type declarations (typedefs). The
syntax is
typedef sequence<ObjectType> ObjectTypeSequence ;
object type contained is identified within “<” and “>” and precedes the word “Sequence” in the
type name. Thus,
typedef sequence<Machine> MachineSequence ;
There is no explicit order implied in any usage of this definition. Where order is important, it will
be so noted in any associated description.
/* The following says operationName1 is a local operation returning an object of the class
ObjectTypeReturned. */
ObjectTypeReturned operationName1 ( );
/* The following says operationName2 is a local operation returning an object of the class
ObjectTypeReturned with an argument instanceName of the object type ObjectTypeName. In
addition, there is an operation-specific exception, E, that may be raised by this operation. */
ObjectTypeReturned operationName2 (in ObjectType instanceName)
raises (E);
In addition, definitions for non-basic types can be found in Section 4.1.1. The type definitions
follow the following format:
/* Type Declarations: */
/* The following specifies (types) the ObjectType for the named datatype. */
typedef ObjectType datatype;
3 JOB ARCHITECTURE
This section describes the core functional architecture of the CIM Frameworkthe creation and
execution of factory jobs made up of process jobs, transport jobs, preventive maintenance jobs,
etc. The overall job architecture integrates the CIM Framework material management
components, the resource and machine management components, and the specification
management components, providing a coherent manufacturing execution system architecture.
The job architecture was influenced by prior work that is described in [Alb], [ISA], [Haw], and
[Will].
Enterprise
... Factory
...
... Area ...
Process Machine Transport Machine Storage Machine Person
• An enterprise often includes multiple factories. The task of the enterprise is to deliver
products to customers.
• A factory is made up of areas and bays with interbay material handling systems. The
task of the factory is to manufacture product lots in response to product requests.
• Areas or bays are made up of processing and metrology equipment with intrabay
material handling systems. The task of the areas or bays is to perform a group of
process operations on groups of materials, move material to the processing
equipment, and perform preventive maintenance and other supporting tasks.
• Complex processing equipment (such as a cluster tool) is made up of processing
chambers and internal material handling and storage resources. The task of the
processing equipment is to perform a process or metrology step or a closely related
group of steps on a material lot or process group. The task of the processing resource
(such as a chamber) is to perform a single process step on a single wafer or a
collection of wafers in a process resource group.
• Material handling and transport systems are made up of interconnected stockers,
tracks, conveyers, robotic handlers and other material storage and movement
equipment. The task of the material handling systems is to store and move materials
in transport groups.
• Manufacturing operators and other factory personnel are important resources to
facilitate and supervise material processing and handling and preventive maintenance
and, in some cases, perform manufacturing steps such as moving material or
performing a visual inspection.
The job control architecture defines how tasks are assigned and coordinated across the hierarchy
of factory resources.
Level is
e
p r
t er Task: Fill Order
En
Notice in Figure 8 that tasks of a higher level are decomposed into combinations of tasks for
lower level resources. Each manufacturing resource has a thread or flow of tasks that must be
coordinated with the tasks of other resources. The higher level task is completed when the
combination of lower level tasks is completed. Figure 8 illustrates this with the coordination of
material movement and lithography operations and with the coordination of operations within the
lithography equipment. The role of job control is to decompose, coordinate, monitor, adjust, and
report on this hierarchical structure of tasks.
The hierarchical task structure of Figure 8 defines the requirements for a multi-level operation
procedure (task) specification model.
Figure 9 shows the elements of a hierarchical task, indicating some of the additional data for an
overall job control structure. A task is specified as a job request from a superior level. Along
with the request is a task specification, which is often a template or procedure for how to carry
out the task, including a combination of subtasks, monitor and adjustment checkpoints along the
way.
As the task is executed, task results are collected in a job history that includes a job identifier, the
(modified) specification used, and recorded inputs and results. Higher level job results could be
a roll-up, an abstraction, or simply pointers to lower level job results.
As each task is started, completed, modified or aborted, appropriate events or other notifications
are emitted. The task endpoints illustrated in Figure 9 as triangles represent factory states or
some specific aspect of a factory state. When a task is completed, the factory state is changed in
the specified way. For example, after a process operation task, product state is changed. When a
movement task is completed, the product location state is changed to the load port for a machine
to perform the next process operation. These intended factory states often have side effects on
other factory states. For example, after a process operation, the equipment state changes to
reflect its utilization, consumables consumption, etc. Job control requires orderly, coordinated,
efficient changes to factory state that result in products, that is, that efficiently transform raw
wafers to product wafers or packaged devices.
Task
Specification
Request
Start End
Event Event
Task
ID: a Sub-
Spec: b
Sub- Sub-Request
Inputs: c Request Request
Results: d
Start End Start End Start End
Event Event Event Event Event Event
Sub-Task Sub-Task Sub-Task
Job Requestor
Specified
Task
Job Control
Resources Materials
of the equipment control.) The job request, status, and feedback information are all candidates
for storage in job history.
Actuation Actuation
Physical Processes
For each job control level in the job hierarchy of Figure 13, there is a corresponding job
supervisor. A FactoryJobSupervisor manages FactoryJobs, an AreaJobSupervisor manages
AreaJobs, and a ProcessMachineJobSupervisor manages ProcessMachineJobs.
Request
Job Specification
Status
Job Supervisor
Material
Feedback
Job Executor Job
Equipment
History
Job
Specification(s)
Status
Request(s)
Note that the job control hierarchy provides interfaces to the enterprise at the top level and the
equipment at the bottom level. The Enterprise level is the requestor of work for the factory.
Enterprise control is outside the MES functional scope of the CIM Framework. The Process
Resource level is also outside the scope of control of the CIM Framework. It is usually
implemented by process controllers embedded in or piggyback on equipment. The Process
Resource level is modeled for the MES to allow process data to be collected and organized for
specific equipment resources such as a specific chamber in a cluster tool. The Area level is
optional or it can be split into multiple levels (such as Cell or Bay).
At each level, job control involves performing specified operations on specified material or
material groups using specified or allocated (dispatched) resources and equipment shown in
Figure 10. Figure 13 shows the job control hierarchy relationships. The resource aspects are in
Figure 7. The operation aspects are in Figure 8 and Figure 9. The material aspects (specifically,
the relationships between product requests, lots, transport groups, process groups, lot splits, and
joins, etc.) are defined as a result of job control deciding what tasks to perform on what material
using what manufacturing resources. This structure of the various material groups and material
genealogy is not illustrated.
As a manufacturing resource, the product material also has a thread of task activity. This thread
is defined by the process flow specification. It defines the sequence of process operations
mapped to machine resources for processing and supported by transport operations for material
movement.
The LotJob controller (Factory Operations) uses the process flow as a LotJob specification and
maps it to the process resource thread, material movement thread, preventive maintenance thread,
and other implementation threads. Tasks for transport resources are managed by a material
movement control system driven by material movement requests to move material to dispatched
process resources. Preventive maintenance tasks are scheduled and managed by a preventive
maintenance system, driven by changes in manufacturing resource state. Advanced process
control computation tasks are triggered and managed by a process management system driven by
performance of process operations and metrology. Obviously, these separate threads of activity
interact with (enable and constrain) each other and with the material and resources the tasks
modify. Factory operations, with factory scheduling and dispatching, ties together all of these
separate threads of task activity into a coordinated, efficient structure of factory tasks.
... ...
Op5 Op6 Op7
Process Flow Specification
for Lot 2
ry
cto Task: Produce Lot 2
Fa ...
.
rev t.
P ain
t M PM
or ...
sp
Move Move
Level r an ...
T
ess
oc ne
Pr chi Litho PM
a ...
M
Process
e
h in ce Operations
r
ac ou ...
M es
R
Time
Lot Job
Lot
ProductionHistory
Area Job
Inventory Region
Process InventoryRegionHistory
Machine
Process Job
Machine
Process Operation
Process
Process Resource Process Resource
Resource Job Group
(material in a given
ProcessRun of a
ProcessOperation)
E10PerformanceHistory ControlDatabase
ResourceMaintenanceLogHistory ControlArchive
ProcessResourceHistory
3.4.3 Where do Job Supervisors (and Jobs) fit within the CIM Framework
Beyond the abstract level of Job Supervision, the CIM Framework should include the following
specializations. Not all components in this version of the CIM Framework have been completely
aligned with this job supervision design.
Product Request Management: This is the highest level Job Supervisor within the Factory,
serving the Enterprise by filling ProductRequests (which are linked to Orders). It delegates the
production of Lots to Factory Operations.
Factory Operations: At this level, the activity request coming in is “make a product wafer from a
bare silicon wafer”. The unit of request is Lot. The Factory Operations level guides the lot
through its process flow and makes sure that supporting activities occur (e.g., equipment
qualifications, preventive maintenance tasks, etc.).
Area Job Supervision: This optional level serves Factory Operations and is responsible for
multiple machine activities (Areas may map to Bays, Cell Controllers, Linked Lithography, etc.).
This level is not required by the Factory, but is available for use. It could be used by sites that
have a factory within a factory model with separate but integrated operations management for
separate units of manufacturing capacity. It could also be used by sites transitioning from legacy
systems, with parts of the factory under a next generation CIM Framework-conformant MES and
other parts under a legacy MES that is fronted or wrapped by a CIM Framework conformant
Area Job Supervisor component. Another example could be a site that provides a pseudo-cluster
cell controller to group stand-alone process equipment into an integrated workcell that behaves
like a cluster tool. There are no separate Area Job Supervision interfaces defined in the CIM
Framework Specification. These functions are met by the ProcessMachineJob interfaces with no
change (The same interface serves both functional roles. Areas typically receive a sequence of
process jobs as a request, whereas simple machines usually receive a single process job).
Machine Job Supervision: This level lies within the CIM Framework Machine Management
component. It accepts activities that apply to a single Machine. It delegates work directly to the
physical equipment, either through some equipment interface driver or directly through the
GEM/SECS interface.
Transport Job Supervision: This level takes requests to move material from one location to
another. While the CIM Framework may provide for layers of TransportJobSupervisors in a
complex system, today’s typical installation has a single proprietary Material Handling System
Controller (TransportJobSupervisor). Machines may also be TransportJobSupervisors, taking
simple tasks of handing off or receiving material. This is under consideration for later
enhancements to the Material Movement components.
Advanced Process Control (APC): APC includes lengthy calculation activities that may not
succeed and which impact the performance of other jobs. For example, an algorithm may not
converge, a sensor may emit bad data, or process machine jobs, recipes or job specifications may
be modified.
Preventive Maintenance (PM): Preventive maintenance is a scheduled activity on specific
resources (machines) using labor resources and materials. PM job progress must be reported and
tracked and PM job history can be stored. The Preventive Maintenance components in Machine
Management provide this functionality.
delegate it to even lower levels. At some point, an activity reaches a resource that can actually
perform the work (e.g., a machine resource).
At any level, the requestor of activity will request work of a JobSupervisor and receive in return
the handle to a Job which represents this work. This requestor will not have visibility to how the
JobSupervisor performs the work beyond what is specified in the original activity specification
and what is reported later as data. Not visible or accessible are the lower activity requests (and
resulting jobs) that may be issued by the JobSupervisor. A requestor will not micromanage the
delegation of tasks. This approach yields the greatest flexibility in the factory system.
The responsibility of the JobSupervisor/Job team is to perform the activity and report back to the
requestor on the success or failure of the effort. There is no limitation on the facilities within the
factory that may be used to accomplish the goal.
A JobSupervisor will have a well defined domain; that is, a set of factory resources that it can
call on to perform work. Only activity requests which can be accomplished within the domain of
a JobSupervisor should be issued to/accepted by that JobSupervisor.
The interface of the JobSupervisor provides high level information about the jobs it is currently
engaged in (and perhaps jobs recently completed). The details of any specific job are provided
by the Job itself, not the JobSupervisor. From the JobSupervisor, the JobRequestor is able to
a. request activity
b. locate jobs that meet certain criteria, and/or
c. request lists of all jobs being performed
The JobSupervisor is not able to provide details (e.g., status or attributes) of any specific job. For
instance, the MachineJobSupervisor is not able to provide the estimated time to completion or
the process recipe of a MachineJob.
This also applies to the control of jobs. The JobSupervisor initiates the creation of jobs (from the
activity request), but thereafter allows only for control of jobs as a group (e.g., abort all jobs) not
abort job X. However, much thought should be given to the use of these all jobs commands
since they can cause a great deal of harm if not designed and used properly.
The Job interface class is the sole source of all public information about a job. It also provides
all specific control of the job (pause, abort, etc.). This is in compliance with the CIM Framework
architectural guidelines.
A job requestor is not designed to micromanage the job. Instead, the job requestor creates a
specification of the work to be done and hands it to the JobSupervisor when requesting the work.
Once the work request is accepted, the JobSupervisor’s component controls the execution of that
job within the limitations of the job specification and its business rules. The only exceptions are
coarse commands such as abort or pause. For instance, if a JobSupervisor is capable of queuing
multiple jobs, it must also have the means to determine the order in which it should execute those
jobs (e.g., first in-first out or perhaps highest priority lot first).
The Job Supervision role has a companion interface that must be inherited or implemented by the
job requestor. This interface defines necessary messages that must be sent by the JobSupervisor
to the requestor . An attempt is made to document who the requestor must/should/might be for a
given Job Supervision derivative, but there may be other job requestors in a factory.
components or objects use it. When classes are defined in a component, they provide an
interfacethis is very clean and predictable. However, since the internal design of each
component is an implementation decision, we cannot say with certainty that a given class will use
an operation provided by another class.
Note that this contributes greatly to the problems of creating scenario as interaction diagrams.
After all, a scenario is a sequence of class instances sending messages to instances of (the same
or) other classes. It is known which class receives the messages and can surmise the order in
which they are sent. However, the best one can do is to determine the component from which the
message is sent. One cannot determine the specific class within the component that sent the
message. Any scenarios published in this document should be viewed in that light.
JobSupervisor
1+
Worker Delegator
The second type of JobSupervisor is a CIM Framework component that leverages other CIM
Framework components to get the work done. In fact, it leverages other JobSupervisors. This is
termed a Delegator. The JobSupervisor, Worker, and Delegator are shown in Figure 16. in the
Composite Pattern (see Design Patterns, Gamma, et. al. [Gam94]. The notation in the diagram
indicates that the Delegator is composed of one or more other JobSupervisors (may be a
collection of Workers and Delegators. This is considered to be a stable, if not necessarily
exclusive relationship. Alternatively, it would have been reasonable to draw this relationship as
a simple association. Since this is for illustration purposes, this is not a crucial distinction.
JobRequestor
contracts 1+
work from
1+
JobSupervisor
1+
Worker Delegator
It should be clear that Job, JobSupervisor, and JobRequestor classes are abstract classes.
Note that the classes that use JobSupervisor (and thus inherit JobRequestor) need not be
JobSupervisors themselves.
/* This type definition represents units for factory parameters, measurements. etc., and conforms
to the SEMI E5 [SEMI97] standard for representation of units. In that standard, the string
contains a code representing a value of the units. For example, “ns” would mean nanoseconds;
“A” for ampere; and “wfr” for wafer. */
typedef string Unit;
typedef string Units;
/* This type definition represents variable data for a machine that must be controlled by either
manual or automatic means for processing Product on that machine. */
typedef struct Setting_structure {
string settingName; // the name of the setting ("Temperature")
any settingValue ; // the value for the setting (e.g., 125)
Unit settingUnits ; // the units of the setting (e.g., “degC")
} Setting ;
/* This enumerated type is necessary for event priorities and is used in each event definition. */
enum PriorityOfEvent { Low, Medium, High, Alarm };
/* This enumerated type is to identify the lifecycle states that an object may go through. */
enum LifecycleState { Undefined, Created, Deleted, Moved, Copied };
/* This enumerated type is to identify the states of objects that can be reserved (Lot, Durable and
Machine). */
enum ReservationState { UndefinedReservationState, Reserved, UnReserved };
/* This enumerated type represents the E10 states for Machines and Machine Resources. */
enum E10State { E10Productive, E10Standby, E10Engineering, E10ScheduledDowntime,
E10UnscheduledDowntime, E10NonscheduledTime };
/* TimeT is a ulonglong value (64 bits) that represents the number of 100 nanosecond increments
that have passed since a base time (October 15, 1582 at 00:00, the Universal Time
Representation which refers to time in Greenwich Mean Time). The CIM Framework uses the
OMG Time Services as a basis for manipulating time operations. The specification for TimeT is:
*/
struct ulonglong
{unsigned long low ;
unsigned long high ; } ;
typedef ulonglong TimeT ;
/* The notion of a specific interval of time denoting a start time and an end time is represented
as a struct called IntervalT. */
struct IntervalT
{TimeT lower_bound ;
TimeT upper_bound ; } ;
/* This typedef structure is for the representation of a single schedule instance that may be used
by any number of CIM Framework entities. It should be noted that “EndTime” should never
proceed “StartTime.” A sequence of these instances would be used to represent a schedule over
time. */
typedef struct ResourceSchedule_Structure {
TimeStamp plannedStartTime;
TimeStamp plannedEndTime;
TimeStamp actualStartTime;
TimeStamp actualEndTime;
} ResourceSchedule;
/* A sequence of Days. */
typedef sequence<Day> DaysWorked;
/* The definition of a sequence of shifts. This sequence is ordered by start times of the shifts,
beginning at midnight and continuing through the day. The sequence cannot have duplicates.*/
typedef sequence<Shift> ShiftSequence;
/* This is information regarding a responsibility owned by factory personnel and the category to
which that responsibility belongs. */
typedef struct PersonResponsibility_Structure {
string responsibilityCategory ;
any responsibility ;
} PersonResponsibility;
typedef sequence<personResponsibility> ResponsibilitySequence;
/* Filter data are attribute names, values and operators which are specified to further qualify a
history event. The filterable data should be well known and standardized. News are attributes
and values are which need not be standardized. */
enum FilteringOperator {Filtering_eq, Filtering_gt, Filtering_lt, Filtering_ge,
Filtering_le, Filtering_ne, Filtering_substr};
typedef struct FilterItem_Structure
{
CosPropertyService::Property aFilterItem;
FilteringOperator operator; // enum
} FilterItem;
typedef sequence<FilterItem> FilterItemSequence;
/* The ExecutionContext is a list of some combination of objects that will uniquely define an
instance of a run of a ControlExecutor. The ControlExecutor running instance will be uniquely
defined by its RunningControlStategy, which is made unique by a combination of a
ControlStategy and the ExecutionContext. Examples of some objects that may be specified in an
ExectionContext include Lot, Machine, ProcessMachineJob, ProcessOperation and
ProcessStep.*/
typedef any ExecutionContext ;
typedef sequence<NameValue> NameValueSequence;
typedef struct DataTagStructure{
string name;
PrimitiveValue value;
} DataTag;
typedef sequence<DataTag> DataTagSequence;
/* Data required by the control executor to perform the requested control actions. */
typedef any ControllerArguments;
/* The GraphData structure holds fault data to be used for the purposes of displaying a graph that
is in some way meaningful for the fault that has been detected.*/
typedef struct GraphData_Structure {
string legend;
LineDataSequence data;
} GraphData;
typedef sequence< GraphData > GraphDataSequence;
/*The LineGraph structure holds all of the information needed to construct a graph of the fault
data. The structure contains GraphDataSequences for the x and y data, such that multiple x and y
series can be displayed on one chart. The default chart type (which can be overridden), for
example scatter, line, bar, pie, etc., can be specified, as well as the title and x and y axis labels.*/
typedef struct LineGraph_Structure {
string title;
string graphType;
string x_label;
string y_label;
GraphDataSequence x_data;
GraphDataSequence y_data;
} LineGraph;
typedef sequence< LineGraph > LineGraphSequence;
typedef NameValueSequence DurationPlan;
/* Reporting Plan – specifies how and when data should be sent back to the requestor.*/
typedef NameValueSequence ReportingPlan;
/* FormatSpec – the format that an observable should be reported back in: float, int, string, etc.*/
typedef ContentType FormatSpec;
typedef struct LimitsStruct {
string aName;
NameValueSequence aUserDefined;
} Limits;
typedef sequence<Limits> LimitsSequence;
/* Misc Typedefs */
typedef long Position;
typedef LongSequence PositionSequence;
typedef any ProcessRunData;
typedef string PluginContentType; /*is this correct*/
/*This signal is raised when an invalid state transition request is made of an object. */
exception InvalidStateTransitionSignal { };
/*This signal is raised when a “set” attribute contains a value out of range. */
exception SetValueOutOfRangeSignal { };
/* This signal is raised when no other defined signal matches the error condition. */
exception FrameworkErrorSignal {
unsigned long errorCode;
any errorInformation;
};
At this time, the following standard errorCode values are documented in the CIM Framework:
• 0 “Not implemented exception.” This code should be used on any method where
the supplier has chosen to not provide implementation but needs to communicate
to the user that nothing has happened as a result of this method invocation.
• 1 “Implemented by subclass exception.” This code should be used on any method
where the supplier assumes a specialized subclass will implement this method. If
this exception is received, the user will realize that an interface has not be
properly specialized.
• 2 “Unknown exception received.” This code should be used on any method where
an unknown exception has been caught by the implementation and, rather than
crashing, the implementation can map the unknown exception into this known
exception. This probably does not aid in program debugging but does prevent
program crashing.
• 3 “Method completion state unknown.” This code should be used on any
invocation where some unknown error has occured that left the server object in an
ambiguous state.
NamedEntity HistoryCollection
is associated
with
Resource Abstract
Interface Group
OwnedEntity any
is owned by
another
Resource
Component
Manager
All CIM Framework interfaces will inherit from one of the interfaces shown in Figure 18.
NamedEntity provides the most basic naming functions. An OwnedEntity is a NamedEntity with
functions supporting the concept of ownership. A Resource is an OwnedEntity that also takes an
active role in product manufacturing. A ComponentManager is a Resource that manages objects
within a component. The use of interface inheritance is a minimum requirement.
Implementations may also use implementation inheritance as deemed appropriate.
/* Tests the equality of the name of the named entity with the name provided as an argument. */
boolean isNamed (in string testName) raises (FrameworkErrorSignal);
/* Returns the histories (events) which have been collected. It is intended that this operation will
be implemented by a subtype of NamedEntity. Returns null if no history is available. */
HistoryEventSequence getHistoryEvents ( ) raises (FrameworkErrorSignal);
Exceptions: None.
Published Events: None.
Provided Services:
/*Set and get owner. */
void setOwner (in any owner) raises (FrameworkErrorSignal);
any getOwner ( ) raises (FrameworkErrorSignal);
/* Perform normal shutdown activities for this Resource. Normal is defined as allowing the
Resource to complete any current activities and gracefully shut down. This should be
implemented by Resource specializations. */
void shutdownNormal ( ) raises (FrameworkErrorSignal);
/* Perform immediate shutdown activities for this Resource. Immediate is defined as a borting or
terminating any current activities and stopping activity as soon as possible. This should be
implemented by Resource specializations. */
void shutdownImmediate ( ) raises (FrameworkErrorSignal);
/* Answer the receiver’s level in the Resource hierarchy. Resource specifies that each different
type of Resource provide a resourceLevel identifier. To illustrate this service, use the Machine
described in the Resource interface description. The level for each of the Resources could answer
the following:
resourceLevel ( ); sent to an instance of Machine answers Machine.
resourceLevel ( ); sent to an instance of ProcessResource answers ProcessResource. */
string resourceLevel ( ) raises (FrameworkErrorSignal);
/* Service explanation: The NamedEntity interface does not specify any scoping of the names. It
is possible (but not recommended) to have multiple instances of a NamedEntity that have the
same string as the name. For the Resource structure to remain flexible yet retain unique
identification, name scoping has been developed. The scoping makes use of the notion of
Resource level and the ownership hierarchy. Unique identification of the MachineResources
within the Machine is obvious but to identify them outside the Machine requires additional
information about their ownership. Thus:
/* Answer if the resource is available. Available means the resource is functional and ready to
accept and perform its normal tasks. Derivatives of Resource are expected to expand this state
(e.g. add sub-interfaces) that explicitly deal with such additional issues as capacity, normal work
versus maintenance, etc. */
boolean isAvailable ( );
/* Answer if the resource is Not Available. Not available means the resource is unable to accept
or begin new tasks. Previously begun tasks may continue in some cases. Derivatives of
Resource are expected to expand this state to explicitly deal with starting up and shutting down
processes as needed. */
boolean isNotAvailable ( );
Dynamic Model:
1
Available
3 4
5
Not Available
Provided Services:
/* This message causes the component to do its portion of the registration interchange with the
factory indicated by the argument. Note this operation will register the Component Manager
with an OMG compliant Trader service [CosTrade]. One of the Trader properties used for
registration must be the Area for this Component Manager. */
void makeRegistered (in MESFactory aFactory)
raises (FrameworkErrorSignal,InvalidStateTransitionSignal);
/* This message causes the component to do its portion to remove its registration from the Trader
service. */
void makeNotRegistered (in MESFactory aFactory)
raises (FrameworkErrorSignal,InvalidStateTransitionSignal);
/* This message causes a registered component to perform its startup sequence. Each manager
gets itself to the point where it is capable of interacting with other components. When it is ready
to support all services defined in the interface, the component manager tells the factory that
component startup is complete. */
void makeStartingUp ( )
raises (FrameworkErrorSignal,InvalidStateTransitionSignal);
/* This message causes the component to perform its shutdown sequence and then enter the state
STOPPED. During shut down activities, time is allotted to bringing the resources of a component
to a safe stopping condition. The component manager tells the factory that component shutdown
is complete. */
void makeShuttingDown ( )
raises (FrameworkErrorSignal,InvalidStateTransitionSignal);
/* This message causes the component to go into the state STOPPED without regard to data loss
or the stopping condition of resources or material. There is no communication with the factory.*/
void makeStopped ( )
raises (FrameworkErrorSignal,InvalidStateTransitionSignal);
NOT AVAILABLE
STOPPED
NOT
REGISTERED
3 6
1 2
STARTING SHUTTING
UP DOWN
REGISTERED
4 5
AVAILABLE
Resource OwnedEntity
Job Requestor
contracts tracks
work from progress via
Person
1+
assigned
supervises to
Job Supervsior Job
The basic Job Supervision component (or abstract group) does not interact with other
components, except to the extent that other components instantiate its interfaces. Figure 21
shows how the interfaces of Job Supervision relate to one another.
Not shown in the diagram is the JobSpecification, a sequence of name value pairs containing the
parameters required to sufficiently define the work to be done. This sequence is passed by the
JobRequestor to the JobSupervisor in the JobRequest message. See the JobSupervisor interface
for more details.
JobSupervision levels are hierarchical. One level may accept a Job and delegate portions of that
Job to lower levels. Jobs, however, are not purely hierarchical. A Job accepted by one
JobSupervisor may be broken down, along with other jobs of that component and reconstituted
as needed to optimize the activities of the factory.
For example, a ProductRequest may ask for 15 wafers of a particular product. The
ProductRequestManager may delegate a LotJob to Factory Operations with a Lot containing
those 15 wafers and 10 more from a different ProductRequest. In the factory, this Lot may be
split up and processed in smaller groups at various stages or, as scrap reduces the wafer count,
combined with another small lot to create a more optimal process group. The Job Supervision
allowed great latitude to optimize performance. Its only requirement is to fulfill the specification
of the Job.
The role of Person in JobSupervision within the Factory is an important one. Most jobs in
today’s semiconductor factories may involve a person in one role or another. Other resources will
also be involved in various derivatives of Job.
Note: “Value Type”, when listing a class, implies an object reference. Simple types imply pass
by value.
/* Defines the type of job being requested. This enum will need to be expanded to include all
types of Jobs which might be requested within a factory system. */
enum JobType { ProductRequestJobType, LotJobType, AreaJobType, ProcessMachineJobType,
TransportJobType, PMJobType, ProcessControlJobType };
Exceptions:
/* Requested Job was rejected. */
exception JobRejectedSignal { };
exception JobNotFoundSignal { };
1
The JobSupervisor may not actually instantiate the new job. That process is encapsulated within the component.
Provided Services:
/* Request that work be done according to the proffered specification. A Job that represents the
work is returned for future reference. */
Job requestJob (in JobType type, in Properties aJobSpecification,
in JobRequestor aJobRequestor)
raises (FrameworkErrorSignal, JobRejectedSignal);
/* Ask whether the job specified by the JobSpecification would be accepted for current or future
(queued) processing if a requestJob message were issued now. */
boolean canPerform (in JobType type, in Properties aJobSpecification)
raises (FrameworkErrorSignal);
/* Command to begin the pausing of all jobs of this JobSupervisor that can be paused (e.g., not
Finished Jobs). */
void pauseAllJobs () raises (FrameworkErrorSignal);
/* Command to resume all Jobs of this JobSupervisor that are currently Paused. */
void resumeAllJobs () raises (FrameworkErrorSignal);
/* This command terminates all the jobs under the control of the JobSupervisor immediately,
without regard to effects on the yield of this product. This service should be used with great
caution. It implies potential loss of material due to incomplete processing that may not be able to
be restarted (e.g. partly etched wafers). */
void abortAllJobs () raises (FrameworkErrorSignal);
/* This command terminates all the jobs under the control of the JobSupervisor at the next safe
opportunity. Safe indicates no potential damage to the product due to stopping in the middle of
processing. In some cases, the job must complete to satisfy this request. */
void stopAllJobs () raises (FrameworkErrorSignal);
/* This service removes a Job that is in the Finished state from the active memory of a
JobSupervisor. Persistent information about the job may be captured in a History. It is also
understood that there may be rules for automatic removal of finished jobs based on time, number
of jobs, or other criteria. */
void removeFinishedJob (in Job aJob) raises (FrameworkErrorSignal);
Published Events:
/* Any time the Job’s state changes. */
JobStateChangedEvent
Provided Services:
/* Ask the Job for its JobRequestor. */
JobRequestor getJobRequestor () raises (FrameworkErrorSignal);
/* The initial value for the deadline attribute will come from the JobSpecification. The Job is
expected to be completed no later than the specified deadline. This provides the JobSupervisor
some ability to plan its execution schedule. The Job shall issue an event when it determines that
this deadline will be exceeded. Any further action is the responsibility of the JobRequestor. */
TimeStamp getDeadline () raises (FrameworkErrorSignal);
/* Get the priority of the Job. Priority ranges from 1 to 99 where 1 is the highest priority and 99
is the lowest. This format matches that of Lot priority. */
long getPriority ( ) raises (FrameworkErrorSignal);
/* Begin the process to pause the Job at the next safe opportunity. Results in the transition to
Pausing state and eventually Paused state. */
void makePaused ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
/* Request the Job resume activity from the previous Pause. Results in the transition to Not
Paused state. */
void makeNotPaused ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
/* Request to cancel the Job. This message is only valid if the Job is in the Queued state (e.g.,
the Job cannot be canceled once it is Active). This message results in the transition to the
Canceled state. */
void makeCanceled ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
/* Begin the process to stop the Job. This is an orderly termination and should never cause
irreparable problems (e.g., should not stop etching a wafer in mid-cycle). This message results in
the transition to the Stopping state and eventually the Stopped state. */
void makeStopped ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
/* Begin the process to abort the Job. Caution should be used with this method. Aborting a Job
requires immediate termination of the Job and could result is loss of product. This message
results in the transition to the Aborting state and eventually the Aborted state. */
void makeAborted ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
/* Return the estimated time remaining until Job completion. The quality of this estimate is
dependent both on the specific Job derivative and on the implementation. If the Job is Finished
or Canceled, a zero Duration will be returned. */
Duration timeRemaining ( ) raises (FrameworkErrorSignal);
Contracted Services:
Interface Component Service
JobRequestor JobSupervision informJobStarted
JobRequestor JobSupervision informJobCompleted
JobRequestor JobSupervision informJobTerminated
Dynamic Model:
Queued Canceled
Active
Executing
Pausing
Aborting Stopping
Finished
For implementations (e.g., Job derivatives), the Executing state is expected to be extended by
partitioning it into at least two orthogonal states. One would hold the Pause states. The other
would contain the implementation behavior of Executing.
Note that state transitions are controlled within the component implementing JobSupervision, so
there are no methods to directly change the state of a Job.
/* The Job reached the FINISHED state without completing the requested work. */
void informJobTerminated (in Job aJob) raises (FrameworkErrorSignal);
Scenario
aJobRequestor: aJobSupervisor: aJob :Job
JobRequestor JobSupervisor
3: informJobStarted (Job)
4: informJobCompleted (Job)
Figure 23 shows the most basic of scenarios for the Job Supervision component. It proceeds in
this fashion:
1. The JobRequestor populates a JobSpecification then requests a job according to that
specification.
2. In response to the Job request, the JobSupervisor facilitates the creation of a Job to represent
the task. A handle to the Job is returned to the JobRequestor (assuming the Job request is
accepted.
3. The Job Supervision component (e.g., in the form of the Job) informs the JobRequestor when
the Job begins.
4. The Job Supervision component (e.g., in the form of the Job) informs the JobRequestor when
the Job has completed (assuming successful completion).
ComponentManager MESFactory
has a
Document
Management
Component DocumentManager
creates and
manages
DocumentSpecification
creates and
manages
1 holds 1
DocumentRevision ProductSpecification
ChangeNotice
4.4.1.1 DocumentManager
Inherited Interface: ComponentManager
Description: The DocumentManager interface is responsible for creating and managing
DocumentSpecifications (maintains a collection of the documents) in the
factory. The DocumentManager provides the protocol necessary to enable/
disable version management for the component.
Exceptions:
/* This signal is raised when an attempt is made to create a document with a name which is used
by an existing document. */
exception DocumentSpecificationDuplicateSignal {string documentName;};
/* This signal is raised when a remove document is attempted and that document contains
revisions. */
exception DocumentSpecificationHasRevisionsNoRemoveSignal{string documentName;};
Published Events:
DocumentLifecycleEvent
VersioningRequiredEvent
Provided Services:
/* Disable version management. */
void versionManagementOff ( ) raises (FrameworkErrorSignal);
/* Return a sequence of all revisions that are associated with and managed by the receiver (a
document). The order implies revision lineage. */
DocumentRevisionSequence allRevisions ( ) raises (FrameworkErrorSignal);
/* This signal is raised when a remove revision is attempted when that revision is not in work. */
exception DocumentRevisionNotInWorkNoRemoveSignal {string revisionName;};
/* This signal is raised when an attempt to retrieve the active revision from the document fails to
find one that has been activated. */
exception NoActiveDocumentRevisionFoundSignal {string documentName;};
Published Events:
DocumentRevisionLifecycleEvent
Provided Services:
/* Adds a DocumentRevision to the list of revisions that are associated with the
DocumentSpecification. */
DocumentRevision addRevision (in DocumentRevision aDocumentRevision)
raises (FrameworkErrorSignal, DocumentRevisionDuplicateSignal);
/* Creates a DocumentRevision to hold a versioned object and stores the revision in the
document. */
DocumentRevision createRevisionNamed_with
(in string revisionName, in any versionedObject)
raises (FrameworkErrorSignal, DocumentRevisionDuplicateSignal);
/* Finds a DocumentRevision. */
Provided Services:
/* Set and get the timestamp indicating when the revision was activated. */
TimeStamp getActivationDate ( ) raises (FrameworkErrorSignal);
void setActivationDate (in TimeStamp activationDate)
raises (FrameworkErrorSignal, TimePeriodInvalidSignal);
/* Get and set the text portion of the DocumentRevision. Note that how this text is laid out is an
implementation detail. */
any getDocumentContents ( ) raises (FrameworkErrorSignal);
void setDocumentContents (in any documentContents)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
/* Allows the revision to indicate that it is the one to use in the collection of revisions of a
document. */
void makeActive ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
/* Retrieves the holding (the object placed under revision management) of this revision. */
any holds ( ) raises (FrameworkErrorSignal);
DocumentRevision
1 4
IN WORK 3 ACTIVE INACTIVE
2 5
has a
Version
Management created and
manages
Component VersionManager ChangeNotice
Published Events:
ChangeNoticeLifecycleEvent
Provided Services:
/* Create a ChangeNotice (a specialization of DocumentRevision) with a name and places it by
name in the collection of change notices and also sets the pointer to its document. */
ChangeNotice createChangeNoticeNamed_inDocument (in string changeNoticeName,
in DocumentSpecification aDocumentSpecification)
raises (FrameworkErrorSignal, ChangeNoticeDuplicateSignal);
/* Find a ChangeNotice. */
ChangeNotice findChangeNoticeNamed (in string changeNoticeName)
raises (FrameworkErrorSignal, ChangeNoticeNotFoundSignal);
/* This signal is raised when an attempt is made to modify a change notice that is not in work
status. */
exception ChangeNoticeNotInWorkSignal { };
/* This signal is raised when an attempt is made to remove a non-existent name from the default
signoff set. */
exception SignOffNameAbsentSignal {string signOffName;};
Published Events
ChangeNoticeStateChangedEvent
ChangeNoticeRejectedEvent
ChangeNoticeSignoffsChangedEvent
Provided Services:
/* Get the DocumentSpecification associated with this ChangeNotice. */
DocumentSpecification getSpecification ( ) raises (FrameworkErrorSignal);
/* Changes the status of the change notice to that of being in work. Changes can be made to this
change notice. */
void makeInWork ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
/* Approve a Change Notice. */
void makePreparingToActivate ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
/* Reject the ChangeNotice (cancel the signoff process) and move back into IN WORK status. */
void rejectSignOff ( ) raises (FrameworkErrorSignal);
/* Provide a set of all the names in the default signoff list. The order may be important in some
cases (implies a priority.) */
stringSequence defaultSignOffSet ( ) raises (FrameworkErrorSignal);
ChangeNotice
1 PREPARING TO
IN WORK 3 ACTIVATED
2 ACTIVATE
ComponentManager
Event
Management
Services
EventBroker
/* This exception is raised when a subscription request is received for an event for which the
EventBroker does not yet have an EventChannel registered. */
exception NoSupplierForTheRequestedEventSignal { };
/* This exception is raised when an invoker requests the de-registration of an EventChannel that
the EventBroker has no record of registering. */
exception EventChannelNotRegisteredSignal { };
/* This method is used by a producer (supplier) of an event (or some other third party object
acting on its behalf) to inform the EventBroker that an EventChannel will no longer be available.
This is only for the information of the EventBroker so that it can maintain its internal tables. The
responsibility for the disconnects of the consumers and the destruction of the EventChannel is
not in the scope of the EventBroker. */
void removeChannelForEvent (in string subject,
in CosEventChannelAdmin::EventChannel anEventChannel)
raises (FrameworkErrorSignal, EventChannelNotRegisteredSignal);
/* This method is used by a consumer of an event to find out about the EventChannels publishing
that CIM Framework event. It is the responsibility of the consumer to perform its own
connectivity to the returned Event Channels. Note that this service could also be used by a
producer (supplier) of an event to find an EventChannel to use for its publication of events if it
doesn’t wish to create a new one.
The precedence of the exceptions is up to the implementer. For example, if a client of this
service asks for an EventChannel that is not for a CIM Framework event and/or not for an event
yet registered, the implementation may raise either of the last two exceptions. However, if the
implementer is not supporting non-CIM Framework events, the UnsupportedEventSubjectSignal
should be raised rather than the NoSupplierForTheRequestedEventSignal. On the other hand, if
the implementation does support non-CIM Framework events, the exception raised should be the
NoSupplierForTheRequestedEventSignal. */
EventChannelSequence allEventChannelsFor (in string subject)
raises (FrameworkErrorSignal, NoSupplierForTheRequestedEventSignal,
UnsupportedEventSubjectSignal);
is associated
with
NamedEntity HistoryCollection History
has
History
Management
Facility
OwnedEntity
has
Resource Area
groups
Machine
/* Remove a History (or Histories) with the key/subject string from this HistoryCollection. The
History is not destroyed by this operation. Returns the History(ies) removed. */
HistorySequence removeHistory(in string historyEventSubject)
raises (FrameworkErrorSignal, HistoryEventNotFoundSignal) ;
/* Find History objects based on the subject string. Returns null sequence if no matches found. */
HistorySequence findHistory(in string historyEventSubject)
raises (FrameworkErrorSignal);
/* Remove HistoryEvent(s) from the history list that matches the input parameters. */
void removeHistoryEvent (in string historyEventSubject,
in TimeStamp startingHistoryEventTS,
in TimeStamp endingHistoryEventTS,
in string historyObject) // can be null
raises (FrameworkErrorSignal, HistoryEventNotFoundSignal);
/* Returns a collection of all the HistoryEvents that match the criteria specified. The support of
the historyEventSubject field should allow for wild cards (‘*’) and support user-defined
extensions to the slash delimited hierarchy. If the historyObject field is “null”, no filtering should
be performed against this field. If the field aFilterItemSequence is “null”, then no filterable data
needs to be used in the query. */
HistoryEventSequence findHistoryEvent (in string historyEventSubject,
in TimeStamp startingHistoryEventTS,
in TimeStamp endingHistoryEventTS,
in string historyObject, // can be null
in FilterItemSequence aFilterItemSequence)
raises (FrameworkErrorSignal) ;
/* Returns the number of items in the collection of all the HistoryEvents that match the criteria
specified. */
long historyEventCount (in string historyEventSubject,
in TimeStamp startingHistoryEventTS,
in TimeStamp endingHistoryEventTS,
in string historyObject, // can be null
in FilterItemSequence aFilterItemSequence)
raises (FrameworkErrorSignal);
Factory Management
Functional Group
Enterprise
Abstract
Interface
Request
factory Request
to fill job(s) Product
to fill
Product
Product
Request
Request
Request Mgmt
Requests
factory-
level Request
services lot(s)
External Factory to fill
Requester Product
Request
Provides
information
on
material to Product
release Release
Factory
Operations
Interpret Initiates
and lot
execute scheduling
schedules
Dispatching
Resource
Factory Machine
maintains
Component registration
Register
of machines
has
ComponentManager MESFactory
used to
configure
is comprised of
Policy
Variable
uses
FactoryCalendar Area
groups groups
Machine
manages
PersonManager Person
Published Events:
MESFactoryStateChangedEvent
Provided Services:
/** These services provide support for factory resources. */
/* Add an area to the receiver. Returns the area. */
Area addArea (in Area anArea) raises (AreaDuplicateSignal, FrameworkErrorSignal);
Contracted Services:
Interface Group Service
MachineRegister Machine Management allMachines ( );
MachineMovementController Material Movement allStorageMachines ( );
Dynamic Model:
NOT AVAILABLE
OFF
10
1
STARTING UP
SHUTTING DOWN
9
SHUTTING
DOWN
IMMEDIATELY
5 2 7 6 8
AVAILABLE
OPERATING
GOING TO
3 STANDBY
4
STANDBY
Current
# State Trigger New State Action Comment
8 STANDBY void SHUTTING void shutdown As an action, messages
makeShuttingDown DOWN Normally ( ); delegated to component
Normally ( ); sent to all managers.
sent to the instance instances of
of MESFactory. registered
Component-
Managers.
9 SHUTTING void makeOff (); OFF void The MESFactory polls the
DOWN sent to the instance componentShutd ComponentManagers and
IMMEDIATE of MESFactory. ownComplete ( ); Resources for completion of
LY sent to the shutdown before the
instance of MESFactory state
MESFactory by transitions to OFF.
the Component
Managers.
MESFactory is
off
event published
by the instance of
MESFactory.
10 SHUTTING void makeOff ( ) ; OFF void The MESFactory polls the
DOWN sent to the instance componentShutd ComponentManagers and
NORMALLY of MESFactory. ownComplete ( ); Resources for completion of
sent to the shutdown before the
instance of MESFactory state
MESFactory by transitions to OFF.
the Component
Managers.
MESFactory is
off
event published
by the instance of
MESFactory.
Published Events:
AreaConfigurationChangedEvent
Provided Services:
/* Answer the Area to which this Area is associated. If no membership has been established, nil
is returned. */
Area getSuperArea ( ) raises (FrameworkErrorSignal);
/* Create an association between an Area and the Area to which it belongs. The service will add
the Area indicated by the argument to the receiver’s set of subareas. The service will also update
the superarea for the argument. The service returns the argument. */
Area addSubArea (in Area anArea)
raises (FrameworkErrorSignal, AreaDuplicateSignal);
/* Remove the association between an Area and the Area to which it belongs. The service will
remove the Area indicated by the argument from the receiver’s set of subareas. The service will
also nullify membership (ownership) for the argument. */
void removeSubArea (in Area anArea)
raises (FrameworkErrorSignal, AreaNotAssignedSignal,
AreaRemovalFailedSignal);
/* Returns the set of subareas associated with this Area, that is, the Areas contained within this
higher-level Area. If no membership has been established, an empty set is returned. */
AreaSequence subAreas ( ) raises (FrameworkErrorSignal);
/* Returns a set of product units that are in storage units, transporters and machines in the
receiver. */
ProductSequence allProductUnits ( ) raises (FrameworkErrorSignal);
/* Get the FactoryCalendar for this area. The set service does not have a public interface as the
Area will have its FactoryCalendar instantiated at startup via configuration utilities. A sub-Area
can override its super-Area’s calendar. If there is only one calendar for the entire factory, then the
implementer may define an Area equivalent to MESFactory. */
FactoryCalendar getFactoryCalendar ( ) raises (FrameworkErrorSignal);
Published Events:
AreaShutdownChangedEvent
Provided Services:
/* Add a sequence of CalendarDays to the calendar. */
void addDays (in CalendarDaySequence aCalendarDaySequence)
raises(FrameworkErrorSignal, DuplicateCalendarDaySignal);
/* Return a CalendarDay represented by the given timestamp. Raise the exception if the given
CalendarDay has not been defined for this area. */
CalendarDay workDay_for (in TimeStamp aTimeStamp)
raises (FrameworkErrorSignal, RequestedDayNotDefinedForAreaSignal);
/* Set and get the policy variable’s facility value initially set by the configuration file at startup. */
any getFacilityValue ( ) raises (FrameworkErrorSignal);
void setFacilityValue (in any facilityValue)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
/* Returns the current value for the policy variable, which is the facilityValue if it was set by
startup configuration; otherwise the defaultValue is used. */
any currentValue ( ) raises (FrameworkErrorSignal);
Published Events:
/*Event indicating that a Machine has been added or removed from the
Factory. */
MachineListChangedEvent
Provided Services:
/* Add a Machine to the set of machine(s) managed by the MachineRegister. */
void addMachine(in Machine aMachine) raises (FrameworkErrorSignal);
ProductRequest
JobRequestor Person
tracks 1+
ComponentManager progress via defines
assigned
to
ProductSpecification
JobSupervisor
ProductRequestExecutor Job
ProcessOperation
requests product be
made from
1+
adheres
to
FactorySupervisor
LotJobExecutor LotJob
has
current
Factory
requests tracks
Operations requests a
movement progress acts
Component process operation
of material with upon
get prioritized
list of tasks
to be done now
ProcessMachine
LotFamily
Dispatcher
TransportJobSupervisor groups
get scheduled 1+ 1+
activities for
Another potential use of the Factory Operations Component is responsibility for interpreting
schedules and initiating CIM Framework operations to carry out the scheduled decisions. This
casts the Factory Operations Component in the role of a client of the Scheduling Component
within Schedule Management. It should be noted that the execution of a single scheduled activity
may result in the initiation of a number of CIM Framework jobs. For example, the decision to
process material at a processing resource may result in transport jobs to move material and other
required resources to the processing resource as well as a process job to carry out the processing
of the material once delivered. A fully automated Factory Operations Component must be aware
of how to carry out a scheduled activity by issuing the right CIM Framework commands at the
right times. This role is a candidate for future study.
Exceptions: None.
Published Events: None.
Provided Services:
/* Return the Dispatchers used by this FactorySupervisor. */
DispatcherSequence getDispatchers ( ) raises (FrameworkErrorSignal) ;
Contracted Services:
Interface Component Service
Dispatcher Dispatching dispatchUsingLots
Dispatcher Dispatching whatNextForMachine
Dispatcher Dispatching whereNextForLot
Provided Services:
/* Get the LotFamily that the LotJob was asked to manufacture. */
LotFamily getLotFamily ( ) raises (FrameworkErrorSignal) ;
/* Get the ProcessFlowContext for each Lot associated with the LotFamily of this LotJob. The
ProcessFlowContext is created by the ProductSpecification at the request of the LotJob */
ProcessFlowContextSequence getProcessFlowContexts ( ) raises (FrameworkErrorSignal);
/* Get all current ProcessOperations associated with any Lot in the LotFamily for this LotJob.
Returns one ProcessOperation per Lot. */
ProcessOperationSequence getCurrentProcessOperations ( )
raises (FrameworkErrorSignal);
/* Change the ProductSpecification for the LotJob (e.g., change the type of finished Product to be
produced). The initial value comes from the ProductRequest. Any change should also come
from there (i.e., the Enterprise level). When a change occurs, each Lot in the LotFamily for this
LotJob will be affected. */
void setProductSpecification (in ProductSpecification aProductSpecification)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
/* Returns how long the LotJob has been in the Active superstate. Note that the duration
returned by age becomes fixed once the entire LotFamily enters the Finished state. */
Duration age ( ) raises (FrameworkErrorSignal) ;
JobRequestor NamedEntity
Enterprise
Abstract Interface
defines
EnterpriseExecutor LotJob
ProductRequest 1+
specifies type
and quantity
of product to make
ProductRequestJob ProductSpecification
ProductRequestManager
Provided Services:
/* Set and get the planned time for release into the Factory. */
TimeStamp getPlanReleaseTime ( ) raises (FrameworkErrorSignal);
void setPlanReleaseTime (in TimeStamp planReleaseTime)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
/* Set and get the quantity of Product (e.g., Wafers) associated with this request. */
long getProductQuantity ( ) raises (FrameworkErrorSignal);
void setProductQuantity (in long productQuantity)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
/* Get the unique identifier for the ProductRequest. Value is set within the Enterprise level. */
string getProductRequestIdentifier ( ) raises (FrameworkErrorSignal);
/* Get the OrderItem associated with this ProductRequest. Since the OrderItem is out of scope of
the CIM Framework, only an identifier is passed across this interface. */
string getOrderItemIdentifier ( ) raises (FrameworkErrorSignal);
/* Set the identifier of the OrderItem associated with this ProductRequest. This change by the
Enterprise level indicates that this ProductRequest has been redirected to a different order. It is
not intended for use by any other component. */
void setOrderItemIdentifier (in string orderItemIdentifier)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
/* Tell the receiver to transition to the ON HOLD state. When a ProductRequest is on Hold, the
related Lots in the factory should react appropriately according to business rules (e.g., Lots might
automatically be put on hold). */
void makeOnHold ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
Not Completed
Not On Hold
3
Completed
1 2
4
On Hold
requests
product
creates defines
lots for product
for
ProductManager ProductRequest
1+
satisfied
FactorySupervisor LotFamily by
Product Request Management employs a delegator style of job supervision. It accepts product
request jobs from the Enterprise interface and releases lots (by requesting lot jobs) to the Factory
Operations component based on those product requests.
The parameter of a product request job specification is the product request. All information
should be available from that interface to perform the work.
Exceptions: None.
Published Events: None.
Provided Services: None.
Contracted Services: None.
Dynamic Model: None.
/* Return all the Lots which have been created, but not released by Product Request
Management. The are the Lots for which this component is responsible. */
LotSequence getUnreleasedLots ( ) raises (FrameworkErrorSignal);
ProductManager
ComponentManager
creates
lots
Product Release
Component
1+
ProductReleaseManager describes ProductRequest
material to
release
releases
1+
initiates lot
scheduling Lot
SchedulingManager
(implementation
dependent)
The Product Release Component is part of a sequence of ordering, planning, and product release,
which takes orders from a customer and results in a sequence of order > order item > product
request > Lot object instance creation.
Figure 38 shows a typical sequence of CIM Framework messages that would occur in causing a
lot to be manufactured. Note that a Scheduling Manager has not been defined for the CIM
Framework. A message taken from an earlier specification release is included to complete this
scenario.
2: createLotUsing( )
3: return aLot
4: return sequence<Lot>
5: scheduleLots(lots)
/* This service is provided for an external entity to force the ProductReleaseManager to create
and release Lots for the given product requests immediately. */
LotSequence createAndReleaseLotsForProductRequests
(in ProductRequestSequence aProductRequestSequence)
raises (FrameworkErrorSignal, ProductRequestInvalidSignal,
UnableToAddProductRequestSignal);
Contracted Services:
Interface Component Service
ProductRequest Enterprise Abstarct is<state>;
Interface
[None defined. Added for clarity.] Scheduling (not schedule lots (no service defined)
defined)
[None defined. Added for clarity.] Planning (not defined) replan order items (no service defined)
ProductReleaseManager Product Release createAndReleaseLotsForProductRequests
(in ProductRequestSequence
ProductRequestSequence);
Lot Product Management makeReleased ( );
ProductManager Product Management allLots<state> ( );
ProductManager Product Management createLotUsing (aProductRequest);
ProductManager Product Management allLotsActive ( );
ProductManager Product Management wipCount ( ); [inherited from ProductManager]
is located on is grouped in
MaterialLocation
Material MaterialGroup
contains
/* Answers whether the receiver is a member of the material group indicated by the argument. */
boolean isMemberOf (in MaterialGroup aMaterialGroup) raises (FrameworkErrorSignal);
/* Adds the argument Material to the collection of Material held by the receiver. The exception is
thrown if the material is a duplicate of material already in the group. */
void addMaterial (in Material aMaterial)
raises (FrameworkErrorSignal,DuplicateMaterialSignal);
/* Removes the Material indicated from the MaterialGroup. Returns the Material removed or
throws the exception if not found. */
void removeMaterial (in Material aMaterial)
raises (FrameworkErrorSignal,MaterialRemovalFailedSignal,
MaterialNotAssignedSignal);
ProductRequest
has a LotJob
manages
manages and tracks ProductManager LotFamily
manages
groups
held at slot
PositionalContainer Cassette
/* This signal is raised when the quantity specified on the ProductRequest does not match the
number of Product units or identifiers sent with a Lot creation request. */
exception ProductRequestQuantityMismatchSignal {long quantityOfMaterial;};
/* This signal is raised if the end time parameter is prior to the start time parameter. */
exception EndTimePriorToStartTimeSignal { };
/* This signal is raised when an attempt is made to add support for another Product Type that
already exists. */
exception ProductTypeDuplicateSignal { };
/* This signal is raised when an attempt is made to remove a ProductType that can’t be found. */
exception ProductTypeNotAssignedSignal { };
exception ProductTypeRemovalFailedSignal { };
/*Indicates One or more of the Product units did not belong to the original Lot.*/
exception ProductNotPresentSignal { };
exception ProcessGroupRemovalFailedSignal
{ProcessGroup aProcessGroup;};
exception ProcessGroupNotAssignedSignal
{ProcessGroup aProcessGroup;};
Published Events:
ProcessGroupLifecycleEvent
LotLifecycleEvent
WaferLifecycleEvent
Provided Services:
/* Create a Lot using the ProductRequest indicated by the first argument. Returns the Lot created.
The ProductRequest contains Product quantity to be created. By default, a LotFamily is created
for the new Lot also. */
Lot createLotUsing (in ProductRequest aProductRequest)
raises (FrameworkErrorSignal);
/* Create a Lot from existing Products. If the ProductRequest quantity doesn’t match the quantity
of Products, the exception is raised. By default, a LotFamily is created for the new Lot.*/
Lot createLotUsing_fromProducts (in ProductRequest aProductRequest,
in ProductSequence aProductSequence)
raises (FrameworkErrorSignal,ProductRequestQuantityMismatchSignal);
/* Create a Lot from existing Products using the given Product identifiers. If the ProductRequest
product quantity doesn’t match the quantity of Product identifiers, raise the exception.
Note: This is designed to be used when pre-existing Products are brought into the manufacturing
facility for further processing. By default, a LotFamily is created for the new Lot also. */
Lot createLotUsing_withIdentifiers (in ProductRequest aProductRequest,
in IdentifiersSequence anIdentifierSequence)
raises (FrameworkErrorSignal,ProductRequestQuantityMismatchSignal);
/* This service causes one new Lot to be split from an original Lot. The service will return the
new Lot containing the Products listed in the second parameter. The original Lot will contain all
remaining Products (if any). The new Lot remains in the original Lot’s LotFamily. This may be
called multiple times if multi-way splits are required. */
Lot createSplitLot (in Lot originalLot,
in SplitProducts productsToSplit)
raises (FrameworkErrorSignal, ProductNotPresentSignal);
/* Create a Wafer. */
Wafer createWaferNamed (in string identifier)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal);
/* Create a Die. */
Die createDieNamed (in string identifier,
in Wafer aWafer, in Coordinate2D aCoordinate)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal);
/* Create a Package. */
Package createPackageNamed (in string identifier)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal);
/* Add a supported Product Type to the collection of types for this Product Manager. See the
definition of ProductType under Product for valid string values. */
void addProductType (in string aProductType)
raises (FrameworkErrorSignal,ProductTypeDuplicateSignal);
/* Remove a ProductType from the supported ones from this Product Manager. */
void removeProductType (in string aProductType)
raises (FrameworkErrorSignal,ProductTypeRemovalFailedSignal,
ProductTypeNotAssignedSignal);
/* Returns raw factory throughput for the product type indicated. This throughput is the number
of product units for the time period indicated.(i.e., the number of wafers). This product type
corresponds to the product type on the Product interface. */
long throughput (in TimeWindow throughputTime, in string aProductType)
raises (FrameworkErrorSignal,EndTimePriorToStartTimeSignal);
/* The receiver joins all of the Lot indicated by the first argument to the Lot indicated by the
second argument. Returns the second argument, which has been modified during the join. The
updated destination Lot is returned. */
Lot joinAll_into (in Lot sourceLot, in Lot destinationLot)
raises (FrameworkErrorSignal,LotJoinFailedSignal);
/* Returns the average cycle time for Lots that have entered the Completed state between the two
timestamps indicated. Returns zero if no Lots have completed within the time specified. */
Duration averageCycleTime (in TimeWindow cycleTime, in string aProductType)
raises (FrameworkErrorSignal,EndTimePriorToStartTimeSignal);
/* Returns the Lot in the domain of the receiver with the name indicated. */
Lot findLotNamed (in string identifier)
raises (FrameworkErrorSignal,LotNotFoundSignal);
/* Returns all current (not finished) Lots that have the ProductSpecification requested. */
LotSequence currentLotsWithProductSpecification
(in ProductSpecification aProductSpecification)
raises (FrameworkErrorSignal);
/* Returns the Products in the domain of the receiver with the name indicated. */
Product findProductNamed (in string identifier)
raises (FrameworkErrorSignal,ProductNotFoundSignal);
/* Returns the Lot of which the Product is a member. The set method has no public interface. */
Lot getLot ( ) raises (FrameworkErrorSignal);
/* Set and get the internally stored serial number for the Product. */
string getSerialNumber ( ) raises (FrameworkErrorSignal);
void setSerialNumber (in string aSerialNumber)
raises (FrameworkErrorSignal,SetValueOutOfRangeSignal);
/* Set and get the Product Type associated with this product. This can be one of the following
valid strings: “Wafer,” “Die,” “Package,” “Multi-chip Module,” or “Cube.” Others can be added
through for future extensibility. */
string getProductType ( ) raises (FrameworkErrorSignal);
void setProductType (in string aProductType)
raises (FrameworkErrorSignal,SetValueOutOfRangeSignal);
/* Returns the position of the Product unit if it is in a PositionalContainer. Raises the exception if
the Product is not in any PositionalContainer. */
long currentPosition ( )
raises (FrameworkErrorSignal,ProductNotInPositionalContainerSignal);
/* Returns the production history of the Product. Production history is defined to be the set of all
process run events associated with the Product. */
HistoryEventSequence getProductionHistory ( ) raises (FrameworkErrorSignal);
NOT
0 1 ALLOCATED
ALLOCATED
IN 2
PRODUCTION
TRAVELING
NOT ON 7 8
3
HOLD
6 IDLE
4 5
9 10
ON HOLD
PROCESSING
11
FINISHED
12 SCRAPPED
13 C 14
PROCESSING
COMPLETED
15
16 SHIPPED
/* Get the Wafer from which the Die came from (or is part of). */
Wafer getOriginalWafer ( ) raises (FrameworkErrorSignal);
/* This signal is raised when an invalid pad coordinate is specified for the Package. */
exception InvalidCoordinateSignal {Coordinate2D invalidCoordinate;};
/* This signal is raised when no Die is found at the specified coordinate of the Package. */
exception NoDieAtCoordinateCannotRemoveSignal {
Coordinate2D specifiedCoordinate; };
/* Remove a Die at the coordinate on the Package. Returns the Die removed. */
Die removeDie_atCoordinate
(in Coordinate2D dieBondCoordinate)
raises (FrameworkErrorSignal,NoDieAtCoordinateCannotRemoveSignal,
InvalidCoordinateSignal);
/* Returns the sequence of Die within this Package. There is no assumed order or pattern to the
sequence returned. Instead, each Die’s coordinate position must be queried for its location within
the Package. */
DieSequence allDie ( ) raises (FrameworkErrorSignal);
/* This exception is raised when the Lot is queried about its completion time but is not yet
completed. */
exception LotNotYetCompletedSignal { };
/* This signal is raised when there are not enough PositionalContainers available in the Factory
to accommodate the Material in the Lot. */
exception InsufficientPositionalContainersForLoadSignal {
long numberOfPositionalContainers;};
/* Raised if the Lot is attempted to be reserved but is already reserved by some other entity. */
exception LotIsAlreadyReservedSignal { };
/* Raised if the lot is reserved and a query to find out who reserved the Lot is invoked. */
exception LotIsNotReservedSignal { };
/*Raised if the Lot is requested to be unloaded from containers but is not in a container. */
exception LotNotInContainerSignal { };
/*Raised when Machines for a Lot requested but the Lot is not at any Machines.*/
exception LotNotAtMachineSignal { };
Published Events:
/* This event is posted when a Lot’s state has changed. */
LotStateChangedEvent
/* This event is posted when a Lot’s quantity of Product has changed due
to scrap, loss, splits, or joins. */
LotQuantityChangedEvent
Provided Services:
/* Get the LotFamily of which the receiver is a member. */
LotFamily getLotFamily ( ) raises (FrameworkErrorSignal);
/*Get the LotJob corresponding to this Lot. This method is delegated to the Lot’s LotFamily.*/
LotJob getLotJob ( );
/* The receiver loads a Lot containing Product into the specified MaterialContainers. */
void loadLotIntoMaterialContainer (in MaterialContainerSequence
aMaterialContainerSequence)
raises (FrameworkErrorSignal,
InsufficientPositionalContainersForLoadSignal);
/* The receiver unloads the Product in the Lot from the MaterialContainer occupied. Returns the
sequence of MaterialContainer from which the Lot was previously occupied. */
MaterialContainerSequence unloadLotFromMaterialContainers ( )
raises (FrameworkErrorSignal);
/* The Products indicated by the first argument are transferred from the receiver to the argument
Lot. */
void transferProducts_toLot (in ProductSequence sourceProducts,
in Lot destinationLot)
raises (FrameworkErrorSignal);
/* Returns the set of all Machines in which the Lot is currently located. These may or may not
correspond to MaterialTrackingLocations as not all Product within a Lot is necessarily being
processed concurrently within a Machine. */
MachineSequence currentMachines ( ) raises (FrameworkErrorSignal);
/* Returns a sequence of Lots that are candidates for a join with the receiver. This interface
behavior is meant to be customized to the practice of a specific manufacturing facility. There
may be different rules for determining join candidates between facilities. */
LotSequence joinCandidates ( ) raises (FrameworkErrorSignal);
/* Returns all the Lots in the Factory that have descended from this Lot. Note that some of the
Lots returned may no longer contain Product due to the result of joins. */
LotSequence allDescendantLots ( ) raises (FrameworkErrorSignal);
/* Returns all Products that are currently members of this Lot. */
ProductSequence allProducts ( ) raises (FrameworkErrorSignal);
/* Once all of the Lot’s Products have gone into the Finished state, this service returns how long
the Completed and Shipped Lot Product members took in the Active and Hold states. If all the
Lot’s Products have not gone into the Finished state, the service returns a zero duration. */
Duration cycleTime ( ) raises (FrameworkErrorSignal);
/* Provide the current yield for this Lot. The calculation for determining yield is implementation
dependent. */
float currentYield ( ) raises (FrameworkErrorSignal);
/* Returns how long the Lot has been in the Active superstate. Note that the duration returned by
age becomes fixed once the Lot enters the Finished state. */
Duration age ( ) raises (FrameworkErrorSignal);
/* Returns the Lot from which the receiver was most recently split. If there have been no splits
for this Lot, the exception is raised. */
Lot mostRecentlySplitFrom ( )
raises (FrameworkErrorSignal,LotHasNotBeenSplitSignal);
/* Returns the time at which the Lot was completed. If the Lot is not yet completed, the exception
is raised. */
TimeStamp actualCompletionTime ( )
raises (FrameworkErrorSignal,LotNotYetCompletedSignal);
/* Returns whether the receiver is the Lot that was originally created and released rather than
split from another Lot. Note that the Products originally started may no longer be members of the
Lot when the query is performed. */
boolean isOriginalLot ( ) raises (FrameworkErrorSignal);
Dynamic Model:
1 CREATED
2
RELEASED
WAITING
6
TO LOGIN
NOT ON
3
HOLD
8 7
4 5
LOGGED 9 LOGGED
IN 10 OUT
ON HOLD
12 11
FINISHED
13 SCRAPPED
EMPTIED C 14
COMPLETED
15
16 SHIPPED
/* This exception is raised if the LotFamily has Lots that are not yet completed. */
exception NotYetCompletedSignal { };
/* Returns Lots that are members of the collection at the time of the query. */
LotSequence currentLots ( ) raises (FrameworkErrorSignal);
/* Returns the Lot that was originally started in the Factory. Note that this Lot may be in archive
(if all of its Products have been joined into another Lot.). */
Lot originalLot ( ) raises (FrameworkErrorSignal);
/* Returns the time the original Lot in the collection was released for production. */
TimeStamp timeStartedInFactory ( )
raises (FrameworkErrorSignal,NoLotHasYetStartedProductionSignal);
/* Returns the time at which all Lots in the collection were completed. */
TimeStamp actualCompletionTime ( )
raises (FrameworkErrorSignal,NotYetCompletedSignal);
/* Returns the Product units scrapped for the LotFamily as a whole. Returns a null list if no
Product has been scrapped. */
ProductSequence productUnitsScrapped ( ) raises (FrameworkErrorSignal);
/* Returns the archive of the LotFamily in which Lots are stored when they cease independent
existence through a join or are completed. */
LotSequence archive ( ) raises (FrameworkErrorSignal);
/* Removes the Lot indicated from the ProcessGroup. Throws the exception if the Lot is not in
the ProcessGroup. */
void removeLot (in Lot aLot)
raises (FrameworkErrorSignal,LotRemovalFailedSignal,LotNotAssignedSignal);
/* Return the sequence of Lots that have one or more Products in this ProcessGroup. The order of
the sequence of the returned value may imply the order of processing. */
LotSequence lots ( ) raises (FrameworkErrorSignal);
SupportResource
has
DurableManager
Durable
1+
holds in
MaterialContainer Material
holds at position
ProcessDurable PositionalContainer
Product
is contained in
/* This signal is raised when there are no PositionalContainers available in the Factory. */
exception NoPositionalContainerAvailableSignal { };
Published Events:
TransportGroupLifecycleEvent
MaterialContainerLifecycleEvent
ProcessDurableLifecycleEvent
Provided Services:
/* Create an instance of TransportGroup, returning that instance. Raise an exception if the
requested TransportGroup already exists. */
TransportGroup createTransportGroupNamed (in string identifier)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal);
/* Create an instance of a Cassette, returning that instance. Raise the exception if the particular
identifier already exists. */
Cassette createCassetteNamed (in string identifier)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal);
/* Create an instance of a ProcessDurable, returning that instance. Raise the exception if the
particular identifier already exists. */
ProcessDurable createProcessDurableNamed (in string identifier)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal);
/* Remove an instance of ProcessDurable. */
void removeProcessDurable (in ProcessDurable aProcessDurable)
raises (FrameworkErrorSignal, ProcessDurableRemovalFailedSignal,
ProcessDurableNotAssignedSignal);
/* Returns all Cassettes whether they are available for use or actively in use. */
CassetteSequence allCassettes ( ) raises (FrameworkErrorSignal);
/* Returns the Cassettes that are available for putting new collections of Product into. */
CassetteSequence availableCassettes ( ) raises (FrameworkErrorSignal);
/* Returns a single available Cassette for putting a new collection of Product into. */
Cassette findAnAvailableCassette ( )
raises (FrameworkErrorSignal,NoPositionalContainerAvailableSignal);
/* Returns a set of Durables to be used for the ProductSpecification and for the specific
ProcessCapability. */
ProcessDurableSequence processDurablesUsed
(in ProductSpecification aProductSpecification,
in ProcessCapability aProcessCapability)
raises (FrameworkErrorSignal,ProcessDurableNotFoundSignal);
/* Raised if the Durable is attempted to be reserved but is already reserved by some other
entity.*/
exception DurableIsAlreadyReservedSignal { };
Published Events:
DurableStateChangedEvent
DurableLocationChangedEvent
DurableReservationChangedEvent
Provided Services:
/* Set and get the location of the durable. */
MaterialTrackingLocation getMaterialTrackingLocation ( ) raises (FrameworkErrorSignal);
void setMaterialTrackingLocation (in MateriaTrackingLocation aMaterialTrackingLocation)
raises (FrameworkErrorSignal,SetValueOutOfRangeSignal);
/* Set and get the lifetime of the Durable item which is the number of times a Durable item may
be used before it wears out or requires maintenance. */
long getTimesUsedLimit ( ) raises (FrameworkErrorSignal);
void setTimesUsedLimit (in long timesUsedLimit)
raises (FrameworkErrorSignal,SetValueOutOfRangeSignal);
/* Set and get the lifetime of the Durable item in terms of time. This is the cumulative time a
Durable item may be used before it wears out or requires maintenance. */
Duration getDurationLimit ( ) raises (FrameworkErrorSignal);
void setDurationLimit (in Duration aDuration)
raises (FrameworkErrorSignal,SetValueOutOfRangeSignal);
/* Get the date and time the Durable item was commissioned. */
TimeStamp getCommissionedTimeStamp ( ) raises (FrameworkErrorSignal);
/* Increments the number of times that the Durable has been used. */
void incrementTimesUsed ( ) raises (FrameworkErrorSignal);
/* Add a Duration of time just used to the Duration of time that the Durable has been used. */
void addDurationUsed (in Duration aDuration) raises (FrameworkErrorSignal);
/* Assign the Durable to a Machine (whether that Machine is a processing machine or a storage
unit.). */
void assignToMachine (in Machine aMachine)
raises (FrameworkErrorSignal,InvalidMachineAssignmentSignal);
Durable
1 3
NOT
AVAILABLE IN USE
AVAILABLE
2 4
6 5 7
SCRAPPED
/* Get and set the ProcessCapabilities for which this ProcessDurable is used. */
ProcessCapabilitySequence getUsedInProcess ( ) raises (FrameworkErrorSignal);
void setUsedInProcess
(in ProcessCapabilitySequence aProcessCapabilitiesSequence)
raises (FrameworkErrorSignal,SetValueOutOfRangeSignal);
/* Get the interface or type of Material the MaterialContainer can hold (e.g., reticle). */
string getContents ( ) raises (FrameworkErrorSignal);
/* Configure the capacity and type of the material the MaterialContainer can hold. */
void configureContainer (in long capacity, in string contents)
raises (FrameworkErrorSignal);
/* Adds Material to the MaterialContainer. The exception is raised when an attempt is made to
add Material to an already full MaterialContainer and not when an addition of Material causes
the MaterialContainer to become full. */
void addMaterial (in Material aMaterial)
raises (FrameworkErrorSignal,MaterialContainerFullSignal);
/* Removes a specific Material from the MaterialContainer. Raises the exception if the Material
is not found in the MaterialContainer or due to an empty MaterialContainer. */
void removeMaterial (in Material aMaterial)
raises (FrameworkErrorSignal,MaterialNotAssignedSignal,
MaterialRemovalFailedSignal);
/* Removes all the Material from the MaterialContainer. Returns an unordered sequence of the
Material unloaded. Raises the exception if the method is called upon an empty
MaterialContainer. Specializations of this interface may override this method to unload and
return the Material in specific order. */
MaterialSequence unloadMaterialAll ( )
raises (FrameworkErrorSignal,MaterialContainerEmptySignal);
/* Returns an unordered sequence of the Material contained. Specializations of this interface may
override this method to return the contained Material in specific orders. */
MaterialSequence containedMaterial ( ) raises (FrameworkErrorSignal);
/* Get the nominal dimension of the Material that the PositionalContainer was designed to hold
at any position. */
long getNominalSize ( ) raises (FrameworkErrorSignal);
/* Adds Material to a specific position number. Raises the exceptions if the position is invalid for
this PositionalContainer or if the position is already occupied. */
void addMaterialAtPosition (in Material aMaterial, in long positionNumber)
raises (FrameworkErrorSignal,PositionInvalidSignal, PositionOccupiedSignal);
/* Removes Material from a specific position number. Returns the Material removed. Raises the
exceptions for either invalid position or unoccupied position in the PositionalContainer. If the
PositionalContainer is empty, the exception raised is still the unoccupied position exception and
not the empty container exception. */
Material removeMaterialFromPosition (in long positionNumber)
raises (FrameworkErrorSignal,PositionInvalidSignal, PositionEmptySignal);
/* Returns a sequence of longs representing the positions in the PositionalContainer that are
empty. There is no assumed order to the sequence of positions returned. A null sequence returned
indicates that there are no empty positions. */
PositionSequence emptyPositions ( ) raises (FrameworkErrorSignal);
/* Removes all Material. Returns the sequence of Material unloaded in the order of position
number. Note that this method is an override of a method in the inherited interface. */
// MaterialOrderedSequence unloadMaterialAll ( )
// raises (FrameworkErrorSignal,MaterialContainerEmptySignal);
/* The specifed position does not exist or cannot hold the material type specified. */
exception PositionInvalidSignal {Position exceptionPosition;};
/* This exception is raised when the position specifed in remove does not contain any wafers. */
exception PositionEmptySignal {Position exceptionPosition;};
exception MaterialContainerFullSignal
{MaterialContainer exceptionMaterialContainer;};
/* The Wafers indicated by the first argument are transferred from this Cassette to the target
Cassette. */
void transferWafers_toCassette (in WaferSequence sourceWafers,
in Cassette destinationCassette)
raises (FrameworkErrorSignal,MaterialContainerFullSignal,
WaferSizeInvalidSignal);
Provided Services:
/* Get and set the TransportJob associated with this TransportGroup. */
TransportJob getTransportJob ( ) raises (FrameworkErrorSignal);
void setTransportJob (in TransportJob aTransportJob)
raises (FrameworkErrorSignal,SetValueOutOfRangeSignal);
/* Removes the MaterialContainer indicated from the TransportGroup. Raises the exception if
the MaterialContainer is not assigned to this Transport Group. */
void removeMaterialContainer (in MaterialContainer aMaterialContainer)
raises (FrameworkErrorSignal,MaterialContainerNotAssignedSignal,
MaterialContainerRemovalFailedSignal);
has a
Consumable Manager
Consumable
Published Events:
ConsumableLifecycleEvent
Provided Services:
/* Create an instance of a Consumable with an initial quantity. Raise an exception if the
requested Consumable already exists. */
Consumable createConsumable (in string identifier,
in long numberOfUnits, in Unit typeOfUnit)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal);
Published Events:
ConsumableStateChangedEvent
ConsumableQuantityChangedEvent
Provided Services:
/* Get the type of the unit. */
Unit getUnit ( ) raises (FrameworkErrorSignal);
/* Get the number of units. */
long getNumberOfUnits ( ) raises (FrameworkErrorSignal);
/* Increments this Consumable by the number of units indicated by the argument. If this
Consumable was formerly in the NotAvailable state and this incremented quantity is now making
the Consumable available for production use, the Consumable state must also be changed to
Available. */
void incrementQuantityBy (in long numberOfUnits) raises (FrameworkErrorSignal);
/* Decrements this Consumable by the number of units indicated by the argument. The exception
is raised if there is not enough quantity remaining to decrement the amount requested. The
amount is not decremented from the remaining amount. If this decrement lowers the quantity to a
level that makes this Consumable unavailable for production, the Consumable’s state must be
changed appropriately. */
void decrementQuantityBy (in long numberOfUnits)
raises (FrameworkErrorSignal,NotEnoughConsumableSignal);
The Inventory Region Management Component provides for monitoring material progress and
location at the factory level. An InventoryRegionManager provides for the definition of
InventoryRegionSystems, which contain InventoryRegions. Each InventoryRegion can then
monitor the movement (or lack of movement) of its part of the particular system that it is
contained in. InventoryRegions record a history of their entries and exits to provide monitoring
and statistics using the InventoryRegionHistory, InventoryRegionEvent, and
InventoryRegionEventData. An InventoryRegion may be updated directly or a RegionSensor can
provide an indirect link from the monitored location to the InventoryRegion. The LotRegion is a
specialization of InventoryRegion which monitors lots, understands that there is material in the
lots, and provides scrap and yield information.
Figure 46 contains the Inventory Region Management Component Informational Model.
This component contains the following interfaces:
• InventoryRegionManager
• InventoryRegionSystem
• InventoryRegion
• LotRegion
• RegionSensor
Movement can be thought of as the entry, residence in the region, and exit of the product being
monitored.
Inventory
Region
Management
Inventory
Region
Manager
creates manages
Inventory
Region
System
is associated
with
RegionSensor
notifies
has
InventoryRegion History Material
is
associated
with
has
LotRegion Lot
/* Answer the default user defined sequence of regions for this system. */
InventoryRegionSequence getDefaultInventoryRegionSequence ( )
raises (FrameworkErrorSignal);
/* Create a new, named InventoryRegion and return it to the sender. The new region is
automatically added to the system. If the name is a duplicate raise an exception. */
InventoryRegion createInventoryRegionNamed (in string identifier)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal);
/* Create a new, named InventoryRegion and return it to the sender. The new region is
automatically added to the system and positioned after the requested region in the default
sequence. If the name is a duplicate raise an exception. If the preceding region cannot be found,
raise an exception. */
InventoryRegion createInventoryRegionNamed_withDescription_afterInventoryRegion
(in string identifier, in string aDescription,
in InventoryRegion anInventoryRegion)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal,
InventoryRegionPrecedingNotFoundSignal);
/* Change the name of the InventoryRegion. Domain name uniqueness is defined within the
system. */
InventoryRegion changeNameForInventoryRegion_to
(inout InventoryRegion anInventoryRegion, in string identifier)
raises (FrameworkErrorSignal,DuplicateIdentifierSignal);
/* Move the region to a new position in the default sequence based on which InventoryRegion
precedes the region being moved. If the preceding region is not found, raise an exception. */
void moveInventoryRegion_afterInventoryRegion
(in InventoryRegion anInventoryRegion,
in InventoryRegion precedingInventoryRegion)
raises (FrameworkErrorSignal,InventoryRegionPrecedingNotFoundSignal);
/* Answer the regions that have been defined for this system. If there are no regions the sequence
will be empty. */
InventoryRegionSequence allInventoryRegions ( )
raises (FrameworkErrorSignal);
/* Answer the names of the regions that have been defined for this system. If there are no regions
the sequence will be empty. */
InventoryRegionNameSequence allInventoryRegionNames ( )
raises (FrameworkErrorSignal);
/* Answer the region with the input name or raise an exception. */
InventoryRegion findInventoryRegionNamed (in string identifier)
raises (FrameworkErrorSignal,InventoryRegionNotFoundSignal);
/* Answer the history of this InventoryRegion. Set method does not have a public interface. */
// HistoryEventSequence getHistoryEvents ( )
// raises (FrameworkErrorSignal);
// removed since interface is an inherited interface
/* Record and update that an abnormal entry happened for this InventoryRegion. */
void abnormalEnter (in Material aMaterial) raises (FrameworkErrorSignal);
/* Record and update that an abnormal exit happened for this InventoryRegion. */
void abnormalExit (in Material aMaterial) raises (FrameworkErrorSignal);
/* Answer the current items which were considered to be at this InventoryRegion at this specific
time. */
MaterialSequence populationAt (in TimeStamp aTimeStamp)
raises (FrameworkErrorSignal);
/* Answer the average population over a specified time period. Since this measure is based on the
time period given, the units for this measure change based on this time period. Example: If the
time stamps represent the start and stop of a shift, the average population is for that shift. If the
time stamps represent the start and stop of the day, the average population is for that day. */
float averagePopulation (in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer the throughput based on the number of exits over a specified time period. It is
implementation-dependent on the selection of normal exits, abnormal exits or both. Since this
measure is based on the time period given, the units for this measure change based on this time
period. Example: If time stamp represent the start and stop of a shift, the throughput is for that
shift. If time stamp represent the start and stop of a day, the throughput is for that day. */
long throughput (in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer a set of lots that had entered by startTime and had not exited by endTime (i.e., are still
in the InventoryRegion). */
MaterialSequence population (in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer the collection of material that entered the region between startTime and endTime. If
no material entered, an empty collection is returned. If the time stamps represent the start and
stop of a shift, the entries are for that shift. If the time stamps represent the start and stop of the
day, the entries are for that day. */
MaterialSequence entries (in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer the collection of material that exited the region between startTime and endTime. If no
material exited, an empty collection is returned. If the time stamps represent the start and stop of
a shift, the exits are for that shift. If the time stamps represent the start and stop of the day, the
exits are for that day. */
MaterialSequence exits (in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer the average cycle time for a specified time period. The average cycle time will be
calculated for material exiting the region during the time period regardless of the enter time.
Cycle time will be expressed in hours per material. For example: a single material in the
InventoryRegion for 5 hours would have a cycle time of 5 hours, which averages to 5 hours since
there is only one material. If a second material has a cycle time of 3 hours, the average cycle time
is now 4 hours ( (5+3)/2 = 4 hours). */
float averageCycleTime (in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer the average day-to-date age of material for this InventoryRegion. Age is defined as the
total amount of time each material spent in this InventoryRegion, (exitTime – enterTime). */
Duration dtdAverageAge ( ) raises (FrameworkErrorSignal);
/* Answer the average day-to-date cycle time of material for this InventoryRegion. Cycle time is
defined: (Age – (non-cycle time)). If a system does not track non-cycle time, then Cycle = Age.
*/
Duration dtdAverageCycleTime ( ) raises (FrameworkErrorSignal);
/* Answer the average day-to-date non-cycle time of material for this InventoryRegion. Non-
cycle time is implementation specific but represents time that should not be considered in
tracking the material. */
Duration dtdAverageNonCycleTime ( ) raises (FrameworkErrorSignal);
/* Answer the average month-to-date cycle time of material for this InventoryRegion. */
Duration mtdAverageCycleTime ( ) raises (FrameworkErrorSignal);
/* Answer the average month-to-date non-cycle time of material for this InventoryRegion. */
Duration mtdAverageNonCycleTime ( ) raises (FrameworkErrorSignal);
/* Answer the average year-to-date cycle time of material for this InventoryRegion. */
Duration ytdAverageCycleTime ( ) raises (FrameworkErrorSignal);
/* Answer the average year-to-date non-cycle time of material for this InventoryRegion. */
Duration ytdAverageNonCycleTime ( ) raises (FrameworkErrorSignal);
/* Return the history events for this InventoryRegion for a specific Material. */
HistoryEventSequence getHistoryEventsForMaterial
(in Material aMaterial) raises (FrameworkErrorSignal);
/* Answer the amount of time that this Material contributes to the time period below. If the enter
time is before the time period and the exit time is after the time period the duration is the entire
time period. If the exit is before the time period or the enter is after the time period, a duration of
zero is returned. This is the basis for statistical calculations. If the time period is invalid, raise
an exception.*/
Duration timeContribution (in Material aMaterial, in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer the age of the Material in the InventoryRegion as a time duration. Age is defined by
1) If the exit has happened, exitTime - enterTime.
2) If the exit has not happened, now - enterTime.
The age for material that has exited will apply to the most recent visit of the material to the
InventoryRegion.*/
Duration age(in Material aMaterial) raises (FrameworkErrorSignal);
/* Answer the cycle time of the Material in the InventoryRegion as a time duration. Non-cycle
time is subtracted from the duration. Cycle time is defined by; 1) if the exit has happened,
exitTime - enterTime - nonCycleTime; 2) if the exit has not happened, now - enterTime -
nonCycleTime. The cycleTime for material that has exited will apply to the most recent visit of
the material to the InventoryRegion.*/
Duration cycleTime (in Material aMaterial) raises (FrameworkErrorSignal);
/* Signals an attempt to retrieve exit information when the material has not yet exited. */
exception MaterialNotExitedSignal { };
exception HistoryEventNotFoundSignal { };
exception LotNotFoundSignal { };
/* Answer the day-to-date number of lots for this LotRegion. This is a count of lots entering the
population from the start of day until the time of the query. */
unsigned long dtdLotsExistingQuantity ( ) raises (FrameworkErrorSignal);
/* Answer the day-to-date amount of material passed for this LotRegion. Passed material is non-
scrapped material at the time of exit. */
unsigned long dtdPassedQuantity ( ) raises (FrameworkErrorSignal);
/* Answer the number of lots for this LotRegion from the start of month until the time of the
query. */
unsigned long mtdLotsExistingQuantity ( ) raises (FrameworkErrorSignal);
/* Answer the number of lots for this LotRegion from the start of month until the time of the
query. */
unsigned long ytdLotsExistingQuantity ( ) raises (FrameworkErrorSignal);
/* Answer the yield for a specified time period. The yield will be calculated for lots exiting the
region during the time period, regardless of the enter time. If the time stamps represent the start
and stop of a shift, the yield is for that shift. If the time stamps represent the start and stop of the
day, the yield is for that day. */
float yield (in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Record and update that an abnormal entry happened for this LotRegion. */
void abnormalLotEnter (in Lot aLot) raises (FrameworkErrorSignal);
/* Record and update that an abnormal exit happened for this LotRegion. */
void abnormalLotExit (in Lot aLot) raises (FrameworkErrorSignal);
/* Answer the quantity (for example: number of wafer) that were contained in the lot when it
exited the region for this event. */
unsigned long getExitQuantity (in HistoryEvent aHistoryEvent)
raises (FrameworkErrorSignal);
/*Answer if the lot has moved from this ProcessOperation during the time period. If the time
period is invalid raise an exception. */
boolean lotMovedFromOperation (in Lot aLot,
in ProcessOperation ProcessOperation, in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer the normal quantity exited for this Lot. If the lot has not exited, raise an exception.*/
unsigned long normalQuantityExited (in Lot aLot)
raises (FrameworkErrorSignal,MaterialNotExitedSignal);
/* Answer the sequence of ProcessOperations that have been completed for the lot of this event
during this time period. If the time period is invalid raise an exception. */
ProcessOperationSequence operationsUsed (in Lot aLot,
in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer the number of product moves that happened during the time period. This is based on
the number of operations completed and the amount of product processed at each operation. If
the time period is incorrect (startTime > endTime) raise an exception. */
unsigned long quantityOfProductMoves(in TimeWindow timePeriod)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/* Answer the number of product moves that happened during the time period for this specific
ProcessOperation. If the operation does not exist, the answer is zero. If the time period is
incorrect(startTime > endTime) raise an exception. */
unsigned long quantityOfProductMoves_forOperationNamed (in TimeWindow timePeriod,
in string processOperationName)
raises (FrameworkErrorSignal,TimePeriodInvalidSignal);
/*Get all history events for the Lot with respect to this region. */
HistoryEventSequence getHistoryEventsForLot (in Lot aLot)
raises (FrameworkErrorSignal,HistoryEventNotFoundSignal);
/* Notify the sensor that an abnormal entry happened for this sensor which will in turn notify
interestedInEntry registrants. */
void abnormalEnter (in Material aMaterial) raises (FrameworkErrorSignal);
/* Notify the sensor that an abnormal exit happened for this sensor which will in turn notify
interestedInExit registrants. */
void abnormalExit (in Material aMaterial) raises (FrameworkErrorSignal);
/* Notify the sensor that an entry happened for this sensor which will in turn notify
interestedInEntry registrants. */
void enter (in Material aMaterial) raises (FrameworkErrorSignal);
/* Note the sensor that an exit happened for this sensor which will in turn notify interestedInExit
registrants. */
void exit (in Material aMaterial) raises (FrameworkErrorSignal);
/* Answer which InventoryRegions have registered an interest in entries with this sensor. */
RegisteredEntitiesSequence interestedInEntry ( ) raises (FrameworkErrorSignal);
/* Answer which InventoryRegions have registered an interest in exits with this sensor. */
RegisteredEntitiesSequence interestedInExit ( ) raises (FrameworkErrorSignal);
MES Component
Factory Manager
has
BOM
Specification Manager
contains
Product BOMBody
Published Events:
BOMSpecificationLifecycleEvent
Provided Services:
/* Creates a BOMSpecification, places it by identifier and priority in the collection of
BOMSpecifications and sets the pointer to its Document. Priority indicates the main BOM and
alternative BOMs for a ProductSpecification (Priority of 0 means that it is a main BOM. */
BOMSpecification createBOMSpecificationNamed_inDocument
(in string identifier, in DocumentSpecification aDocumentSpecification,
in ProductSpecification aProductSpecification, in long Priority)
raises (FrameworkErrorSignal, DuplicateIdentifierSignal);
/* Returns a set of all of the BOMSpecifications that are managed by the BOMSpecification
Manager. */
BOMSpecificationSequence allBOMSpecifications ( ) raises (FrameworkErrorSignal);
/* Finds a BOMSpecification. */
BOMSpecification findBOMSpecificationNamed (in string identifier)
raises (FrameworkErrorSignal, BOMSpecificationNotFoundSignal);
/* Create and add a BOMBody into the collection of BOMBod (ies) for this
BOMSpecification.*/
BOMBody createBOMBody (in ProductSpecification childProduct)
raises (FrameworkErrorSignal, DuplicateBOMBodySignal);
/* Remove and delete a BOMBody from the collection of BOMBod (ies) for this
BOMSpecification. */
void removeBOMBody (in BOMBody aBOMBody) raises (FrameworkErrorSignal);
/* Set and get the unit of child parts (Wafer, Die, etc.) */
Unit getChildPartsUnit ( ) raises (FrameworkErrorSignal);
void setChildPartsUnit (in Unit childPartsUnit)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
Product
Specification
Management
Component
Product
Process Specification
Flow < tracked
Manager
Context with Document
managed Revision
in >
v manages
Process
Flow
< navigated
Iterator with
Product
Specification < adheres to Lot
Job
Request
The information model shows the relationship between the component’s interfaces and other
interfaces external to the component. The principal entry point to the component is the
ProductSpecificationManager. It shows that a ProductRequest has a ProductSpecification for
definition of a Lot. The Lot can then use the ProductSpecification from the ProductRequest to
create its ProcessFlowContext.
/* Finds a ProductSpecification. */
ProductSpecification findProductSpecificationNamed
(in string productSpecificationName)
raises (FrameworkErrorSignal,ProductSpecificationNotFoundSignal);
Process
Lot
Job
Specification
Management Product
Specification
tracks defines
progress with process for
Process
Specification
uses Lot
tracks
Process progress of
uses
Resource
can be
performed by Process
Capability
Process
Specification
Management
Process Component
Specification
Manager
manages manages
Lot
Job
tracks
progress with
navigates flow with
Process Process
Flow Flow
Iterator Context tracks
progress of
Lot
Product
Specification
Process
template for Process
Operation
Operation
Specification
uses
uses
uses uses
Process Process
Resource Capability
/* Delete a ProcessFlowIterator.*/
void removeProcessFlowIterator (in ProcessFlowIterator aProcessFlowIterator)
raises (FrameworkErrorSignal, ProcessFlowIteratorNotAssignedSignal,
ProcessFlowIteratorRemovalFailedSignal);
/* Delete a ProcessFlowContext.*/
void removeProcessFlowContext (in ProcessFlowContext aProcessFlowContext)
raises (FrameworkErrorSignal, ProcessFlowContextNotAssignedSignal,
ProcessFlowContextRemovalFailedSignal);
/* Returns the ProcessOperationSpecification that is the next in the default traversal of the flow.
If there are no more ProcessOperationSpecifications, raise the exception
NoMoreProcessOperationSpecificationsSignal. */
ProcessOperationSpecification getNextProcessOperationSpecificationOnDefaultPath ()
raises (FrameworkErrorSignal, NoMoreProcessOperationSpecificationsSignal);
/* Returns the ProcessOperationSpecification that is the previous in the backward traversal of the
flow. The operation will return the ProcessOperationSpecification previously visited or the prior
instance along the default path. If there are no more ProcessOperationSpecifications, raise the
exception NoMoreProcessOperationSpecificationsSignal. */
ProcessOperationSpecification getPreviousProcessOperationSpecification ()
raises (FrameworkErrorSignal, NoMoreProcessOperationSpecificationsSignal);
/* Returns a sequence of the ProcessOperationSpecifications that are next in the forward traversal
of the flow. If there are no alternatives the default ProcessOperationSpecification will be
returned in a sequence of one. The order of the returned ProcessOperationSpecifications is not
significant. If there are no more ProcessOperationSpecifications, raise the exception
NoMoreProcessOperationSpecificationsSignal. */
ProcessOperationSpecificationSequence
getAlternativeProcessOperationSpecifications ()
raises (FrameworkErrorSignal,
NoMoreProcessOperationSpecificationsSignal);
/* Returns the set of ProcessResources that can possibly perform the specified
ProcessOperation. The order of the sequence may imply the priority of
ProcessResource selection. Returns NULL if no ProcessResources qualify. */
ProcessResourceSequence processResources ( ) raises (FrameworkErrorSignal);
/* Returns the set of durables required for this ProcessResource to perform this
ProcessOperationSpecification. Returns NULL if no durables are required. */
DurableSequence getDurablesForProcessResource
(in ProcessResource aProcessResource)
raises (FrameworkErrorSignal, ProcessResourceNotAssignedSignal);
/* Returns the set of consumables required for this ProcessResource to perform this
ProcessOperationSpecification. Returns NULL if no consumables are required. */
ConsumableSequence getConsumablesForProcessResource
(in ProcessResource aProcessResource)
raises (FrameworkErrorSignal, ProcessResourceNotAssignedSignal);
/* Returns the processing time required for this ProcessResource to perform this
ProcessOperationSpecification. */
Duration getProcessingTimeForProcessResource
(in ProcessResource aProcessResource)
raises (FrameworkErrorSignal, ProcessResourceNotAssignedSignal);
/*
Note for future consideration: These operations on ProcessOperation may also be needed for
ProcessOperationSpecification
- getRecipeforProcessResource
- getOperatorInstructions fPR
- getRequiredSetup fPR
- getSettings fPR
They are part of the specification (in the hidden ProcessSpec document).
*/
/* Returns a boolean on the comparison between ProcessOperationSpecifications. */
boolean isEqualTo
(in ProcessOperationSpecification testProcessOperationSpecification)
raises (FrameworkErrorSignal);
Published Events:
/* This event is posted when the Process Flow Context changes. This will
occur whenever the result of the currentProcessOperation operation would
change due to a continueProcessing request. */
ProcessFlowContextChangedEvent
Provided Services:
/* Set and get the unique identifier. */
string getIdentifier ( ) raises (FrameworkErrorSignal);
void setIdentifier (in string identifier)
raises (FrameworkErrorSignal, DuplicateIdentifierSignal);
/* Updates the current ProcessOperation to the next ProcessOperation in the flow. The
ProcessFlowContext is associated with a specific Lot being processed. Conditionals and loops in
the process flow will be interpreted by the implementation of continueProcessing, but will not be
exposed in the interface. */
void continueProcessing ()
raises (FrameworkErrorSignal, InvalidLotStateSignal);
/* This exception is raised when there is no recipe for the requested ProcessResource. */
exception RecipeNotFoundSignal { } ;
/* Returns the ProcessCapability that defines all of the ProcessResources that can possibly
perform the specified ProcessOperation.*/
ProcessCapability getProcessCapability ( ) raises (FrameworkErrorSignal);
/* Returns the sequence of ProcessResources that can possibly perform the specified
ProcessOperation. The order of the sequence may imply the priority of ProcessResource
selection. The returned sequence of ProcessResources is based on the appropriate
ProcessCapability. Returns NULL if no ProcessResources qualify. */
ProcessResourceSequence processResources ( ) raises (FrameworkErrorSignal);
/* Returns a Boolean on the comparison between ProcessOperations. This is not a test for
identity; it is a test of equivalence defined by the interface implementation.*/
boolean isEqualTo (in ProcessOperation testProcessOperation)
raises (FrameworkErrorSignal);
/* Returns the set of durables for a specific ProcessResource. Returns NULL if no durables are
required. */
DurableSequence getDurablesForProcessResource
(in ProcessResource aProcessResource)
raises (FrameworkErrorSignal, ProcessResourceNotAssignedSignal);
Process
Capability
Management
Component
Process
Capability
Manager
v manages
Process
Operation identifies Process < capable of
resources Capability performing Process
with >
Resource
Published Events:
ProcessCapabilityLifeCycleEvent
Provided Services:
/* Creates a ProcessCapability and places it by name in the collection of ProcessCapabilities. */
ProcessCapability createProcessCapabilityNamed (in string processCapabilityName)
raises (FrameworkErrorSignal,ProcessCapabilityDuplicateSignal);
/* Removes a ProcessCapability. */
void removeProcessCapabilityNamed (in string processCapabilityName)
raises (FrameworkErrorSignal,ProcessCapabilityRemovalFailedSignal,
ProcessCapabilityNotAssignedSignal);
/* Provides a set of all of the ProcessCapabilities that are being managed by the
ProcessCapabilityManager. */
ProcessCapabilitySequence allProcessCapabilities ( ) raises (FrameworkErrorSignal);
/* Finds a ProcessCapability. */
ProcessCapability findProcessCapabilityNamed (in string processCapabilityName)
raises (FrameworkErrorSignal,ProcessCapabilityNotFoundSignal);
Provided Services:
/* Get the unique identifier for the ProcessCapability. */
string getProcessCapabilityIdentifier ( ) raises (FrameworkErrorSignal);
/* Remove a ProcessResource from the set of ProcessResources that can perform this
ProcessCapability. */
void removeProcessResource (in ProcessResource aProcessResource)
raises (FrameworkErrorSignal);
NOTE: This group and the Material Movement Component were defined prior to the Job
Architecture. Therefore the interfaces are not in full alignment with the Job Architecture.
TransportJobSupervisor
creates and
manages
Material Movement
Management Material Movement Abstract Interface Group
Published Events:
TransportJobSupervisorConfigurationChangedEvent
Provided Services:
/* These services act as the main entry points into the transport system(s). Each service will
create a new TransportJob that will move a TransportGroup to the provided destination(the
source location is provided by the TransportGroup’s contained material). Actual material
movement systems may vary in their specification for the granularity of movement; therefore,
there are three services to provide the destination specification:
Area Destination can be any StorageMachine that supports the given Area and it is the
responsibility of the material movement system to decide where to put the material.
Machine Destination is a specific machine (most likely, but not necessarily, a process machine). The
material movement system can decide which port on the machine should be used.
PortSequence Destination is one of the specific ports listed in this sequence (note that the sequence can
contain only one port for a very specific move.) If the sequence contains more than one port,
it is up to the material movement system to decide which port to use.
Some instances of TransportJobSupervisors may not accept all forms of destination type, hence
the ability to throw exceptions for unsupported destination types.
The parameter for requester is the instance that will be notified when the TransportJob is
completed. The requester must implement the informJobCompleted method.
If the TransportJobSupervisor already has a job for the given TransportGroup and a new create is
requested, it is an implementation detail as to how that is handled. Possibilities include a
cancellation of the current move and creation of a new move, waiting for the first move to
complete prior to executing the next move, or rejecting it. */
TransportJob createTransportJob_toArea (in TransportGroup aTransportGroup,
in Area destination, in Machine origination, in any requester)
raises (FrameworkErrorSignal,UnsupportedDestinationTypeSignal,
AreaNotReachableSignal,AreaNotEnabledSignal,
MachineNotReachableSignal,MachineNotEnabledSignal);
TransportJob createTransportJob_toMachine (in TransportGroup aTransportGroup,
in Machine destination, in Machine origination, in any requester)
raises (FrameworkErrorSignal,UnsupportedDestinationTypeSignal,
MachineNotReachableSignal,MachineNotEnabledSignal);
TransportJob createTransportJob_toMaterialPorts (in TransportGroup aTransportGroup,
in MaterialPortSequence destination, in Machine origination,
in any requester)
raises (FrameworkErrorSignal,UnsupportedDestinationTypeSignal,
MaterialPortNotReachableSignal, MaterialPortNotEnabledSignal,
MachineNotReachableSignal,MachineNotEnabledSignal);
/*Returns a sequence containing all of the Areas that the entities controlled by the
TransportJobSupervisor can physically reach.*/
AreaSequence allReachableAreas ( ) raises (FrameworkErrorSignal);
/*Returns a sequence containing all of the Areas that the entities controlled by the
TransportJobSupervisor are authorized to reach.*/
AreaSequence allEnabledAreas ( ) raises (FrameworkErrorSignal);
/*Returns a sequence containing all of the Machines that the entities controlled by this
TransportJobSupervisor can physically reach.*/
MachineSequence allReachableMachines ( ) raises (FrameworkErrorSignal);
/*Returns a sequence containing all of the Machines that the entities controlled by the
TransportJobSupervisor are authorized to reach.*/
MachineSequence allEnabledMachines ( ) raises (FrameworkErrorSignal);
/*Returns a sequence containing all of the MaterialPorts that the entities controlled by this
TransportJobSupervisor can physically reach directly.*/
MaterialPortSequence allReachableMaterialPorts ( ) raises (FrameworkErrorSignal);
/*Returns a sequence containing all of the MaterialPorts that the entities controlled by the
TransportJobSupervisor are authorized to reach.*/
MaterialPortSequence allEnabledMaterialPorts ( ) raises (FrameworkErrorSignal);
/*Inform the TransportJobSupervisor that the machine involved is ready for sending or receiving
Material. */
void informMachineReadyforMaterialTransfer
(in Port aPort, in Machine aMachine, in TransportJob aTransportJob);
Area getOriginationArea ( )
raises (FrameworkErrorSignal, AreaUndeterminableSignal);
Machine getOriginationMachine ( )
raises (FrameworkErrorSignal,MachineUndeterminableSignal);
PortSequence getOriginationPorts ( )
raises (FrameworkErrorSignal,MaterialPortUndeterminableSignal);
/* This is essentially a hint that this job should be completed by the specified time. The job
executor may ignore this hint or it may try to do intelligent buffering or scheduling. Setting this
does not make the job active. */
void setTargetCompletionTime (in TimeStamp targetCompletionTime)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
TimeStamp getTargetCompletionTime( ) raises (FrameworkErrorSignal);
/* Estimate when this job could begin execution, given current scheduling constraints. */
TimeStamp couldStartTime ( )
raises(FrameworkErrorSignal,TimeUndeterminableSignal);
/*Returns a list of all material in transit in the domain of this material movement controller. */
MaterialSequence allMaterialInTransit ( ) raises (FrameworkErrorSignal);
/*Returns a list of all material in storage in the domain of this material movement controller. */
MaterialSequence allMaterialInStorage ( ) raises (FrameworkErrorSignal);
Advanced
Factory
Process
Operations
Control
requests and tracks provides
processing in settings and
tests results
for APC
informs PM
needed
Machine Recipe
Group manages recipes, Management
manages PM performs recipe
specifications for upload, download,
support and updates
resources
Resource provides
synchronization
Tracking for material
records
processing
movement history for
Material History
Factory Labor
Movement Management
• Machine Group: Machine and resource management and control process job and material
tracking interfaces
• Recipe Management: Provides recipe management and storage for process resources
1+
Support
Resource
groups registers
Machine
Sensor Port
Resource
1+
has one or
more ports
Machine
Material
Tracking
has a
Location 1+
maintains
location of
Machine Process Process
Machine Resource
material
Group
1+
possible and
assigned Process
Material Capability
The Process Machine Management component implements the Job Supervision capability. It is
at this level (from the Factory System point of view) that work is actually performed. This
means simply that work requested of the ProcessMachine is not delegated to any lower level
entity known to the Factory System. As a result of this worker role, the interface responsible for
delegated work, the JobExecutor does not appear in this Job Supervision derivative. Derivatives
where it does appear include the Factory Operations and Product Request levels.
Machine JobRequestor
tracks progress
performs
ProcessMachine ProcessMachineJob
performs
acts upon
1+
Process
ProcessGroup
Operation
The Process Machine Management component primarily exists to perform processing on groups
of product. For any ProcessMachineJob, it will perform a sequence of ProcessOperations
(usually one) on the specified product. Process Operations could include more operational steps
as is in the case of Cluster tools. The CIM Framework does not specify the required interfaces,
but it recommends to be aligned with current proposals for Process Program Management,
Recipe Management, and the Object Based Equipment Model (OBEM).
Provided Services:
/* Reserve a SupportResource. SupportResources may be reserved for only one entity. Return
true if successful. Note: Reserving a SupportResource may effect the reserver more than the
reserved. */
boolean reserveFor (in NamedEntity requester)
raises (FrameworkErrorSignal);
/* Unreserve a SupportResource. */
void unReserve () raises (FrameworkErrorSignal);
/* Return the NamedEntity for which the SupportResource has been reserved. */
NamedEntity reservedFor () raises (FrameworkErrorSignal);
/*Get the PMSpecification(s) associated with this Support Resource, return null if no
PMSpecification is associated. */
PMSpecificationSequence getPMSpecifications ()
raises (FrameworkErrorSignal);
/* E10 State change setting for the resource is not a valid transition. */
exception InvalidStateTransitionSignal { };
Published Events:
/* An E10 State change has occured in the MachineResource that the
Factory needs to know. */
MachineResourceE10StateChangedEvent
Provided Services:
/* Set and get a description for the MachineResource. */
string getDescription ( ) raises (FrameworkErrorSignal);
void setDescription (in string description)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
/* Set and get the factory inventory control number, which may be different from the Machine
identifier.*/
/* Get the Machine this MachineResource is assigned to. Return null if there is no containing
Machine. */
Machine getContainingMachine ( ) raises (FrameworkErrorSignal);
/* Get the MachineResource this MachineResource is assigned to. Return null if there is no
containing MachineResource. */
Machine getContainingMachineResource ( ) raises (FrameworkErrorSignal);
/*Set and get MachineResource’s E10 state code. Answer the MachineResource's E10 state.
The returned string shall be a 4 character string and shall be compliant with the SEMI E58
(ARAMS). The first character is a numeric value from 1-6. The second character is a numeric
value (see SEMI E58 for the specific value assignment). The third and fourth character can be
alphabetic or numeric and is left up to the implementer. */
void setE10StateCode (in string aE10StateCode)
raises (FrameworkErrorSignal, InvalidStateTransitionSignal);
string getE10StateCode ( ) raises (FrameworkErrorSignal);
/* This signal is raised when an attempt is made to deassign a Durable from a Machine to which
it is not assigned .*/
exception DurableNotCurrentlyAssignedSignal {Durable aDurable; } ;
Published Events:
/* Inform that Machine Setup changed. */
MachineSetupChangedEvent
Provided Services:
/*Add and remove Durable to a Machine.*/
void assignDurable( in Durable aDurable)
raises(FrameworkErrorSignal,DurableAlreadyAssignedSignal);
void removeDurable( in Durable aDurable)
raises(FrameworkErrorSignal,DurableNotCurrentlyAssignedSignal);
/* Answer the operators which are currently assigned to work on this machine. */
PersonSequence assignedOperators( ) raises (FrameworkErrorSignal);
/* Answer the operators which are currently performing tasks related to this machine. */
PersonSequence currentOperators( ) raises (FrameworkErrorSignal);
/* Answer the physical location of this machine. Implementations may use different coordinate
systems for tracking machine locations. This location does not relate to
MaterialTrackingLocation. */
string location( ) raises (FrameworkErrorSignal);
/*Set the MaterialTrackingLocation for this machine. This is the one location used for tracking
the particular material type that is in, at, or on this machine. Other material types can have a
separate MaterialTrackingLocation on this machine.*/
void setMaterialTrackingLocation
(in MaterialTrackingLocation aMaterialTrackingLocation,
in Unit aMaterialType)
raises (FrameworkErrorSignal);
/*Get the MaterialTrackingLocations for this machine, There is one and only one
MaterialTrackingLocation per Material type used in the Machine.*/
MaterialTrackingLocationSequence getAllMaterialTrackingLocations ( )
raises (FrameworkErrorSignal);
/*Get the MaterialTrackingLocation of the type requested. Standard unit types can be found in
the SEMI E5 standard. */
MaterialTrackingLocation getMaterialTrackingLocation (in Unit aMaterialType)
raises (FrameworkErrorSignal);
/*Request a Machine ready itself to load material. This may involve communication between the
Port and the Machine Objects but these need not be public (or may involve communciation
between the Machine and the Equipment). The TransportJob may have a specific port as its
destination. The Machine may raise an exception if the specified Port is incorrect. Returns Null
if Machine cannot or refuses to comply.*/
Port prepareToReceiveMaterial(in TransportJob aTransportJob)
raises (FrameworkErrorSignal, InvalidPortSignal);
/* Request a Machine make itself to unload material. Returns Null if Machine cannot or refuses
to comply.*/
Port prepareToSendMaterial(in TransportGroup aTransportGroup)
raises (FrameworkErrorSignal, InvalidMaterialSignal);
Published Events:
/* Indicates that ProcessRunSize for the ProcessMachine has changed. */
ProcessRunSizeChangedEvent
Provided Services:
/* Answers all the ProcessResources this machine owns. */
ProcessResourceSequence allProcessResources( ) raises (FrameworkErrorSignal);
/*Get the units (e.g., Wafers, Cassette) for this process machine. */
Units getProcessGroupSizeUnits ( ) raises (FrameworkErrorSignal);
/*Answer a sequence of ProcessCapabilities representing the setups allowed for each of the
ProcessResources contained within the Machine. */
ProcessCapabilitySequence allAssignedProcessResourceCapabilities ( )
raises (FrameworkErrorSignal);
/*
Contracted Services: None.
Dynamic Model: None.
Published Events:
/* Inform Factory that Process Resource Capability has been changed. */
ProcessResourceProcessCapabilityChangedEvent
Provided Services:
/* Set and get the single ProcessCapability representing the current setup (configuration of
consumables and fixtures) of this ProcessResource. This ProcessCapability must be in the
assigned list.*/
ProcessCapability getCurrentCapability ( ) raises (FrameworkErrorSignal);
void setCurrentCapability (in ProcessCapability aCurrentCapability)
raises (FrameworkErrorSignal, CapabilityNotAssignedSignal);
Provided Services:
/*Query is the Port Ready to accept a reservation. If the Port is in the NotReady state the Port can
refuse to prepare itsself to receive or to send.*/
boolean isReady( ) raises (FrameworkErrorSignal);
AVAILABLE NOTAVAILABLE
READY
NOT
RESERVED
5 6 3
RESERVED
RESERVED
TO
TO SEND
RECEIVE
4
7 NOT READY 8
/* Material specified in the call is not a valid Material for this MaterialTrackingLocation. */
exception InvalidMaterialTypeSignal { };
Published Events:
MaterialTrackingLocationMaterialChangedEvent
MaterialTrackingLocationStateChangedEvent
Provided Services:
/*return the Material at the MaterialTrackingLocation, return nil if the location is empty.*/
MaterialSequence allMaterialHeld () raises (FrameworkErrorSignal);
/*Answer the Machine that holds this MaterialTrackingLocation, return nil if this is a
MaterialTrackingLocation with no Machine (e.i., a table or other place). */
Machine getMachine ( ) raises (FrameworkErrorSignal);
/*Set the material types that can be held in the MaterialTrackingLocation. For example; if the
MaterialTrackingLocation is to hold wafers, the type could be wafer. If it was a particular size of
Wafer, the format could be 200mmWafer. This set of types should be standardized on a list of
Material formats for each given industry. For the semiconductor industry that set of standards
should be based on E5. This will usually be not product, but durables like Cassette, SMIF pod,
reticle holder etc. */
void setUnit (in Unit aMaterialType)
raises(FrameworkErrorSignal, InvalidUnitSignal);
/*This is a query for the availability status of the MaterialTrackingLocation. Available means the
MaterialTrackingLocation has available capacity in which more material could go. */
boolean hasAvailableCapacity ( ) raises (FrameworkErrorSignal);
Component Named
Manager Entity
Recipe Management
Component (Factory Level)
Recipe
Control
Transfers
recipes
to/from
Process
Machine associated with
/* Get the recipe contents. For additional detail on the structure of the recipe contents refer to
SEMI E42. */
Properties getRecipeContents( ) raises (FrameworkErrorSignal);
/* Get the recipe’s verified state. The setting of this parameter is implementation dependent but
must comply with the behavior stated in the RMS Standard (See SEMI E42 for more detail). */
boolean isRecipeVerified( ) raises (FrameworkErrorSignal);
/* Get the recipe protection status. The setting of this parameter is implementation dependent but
must comply with the behavior stated in the RMS Standard (See SEMI E42 for more detail). */
boolean isRecipeProtected( ) raises (FrameworkErrorSignal);
/* Get the recipe approval status. The setting of this parameter is implementation dependent but
must comply with the behavior stated in the RMS Standard (See SEMI E42 for more detail). */
short getRecipeApproval( ) raises (FrameworkErrorSignal);
/* Get the recipe certification status. The setting of this parameter is implementation dependent
but must comply with the behavior stated in the RMS Standard (See SEMI E42). */
short getRecipeCertification( ) raises (FrameworkErrorSignal);
/* Get and set the estimate of the time the nominal recipe requires to run. */
Duration getRecipeEstimatedRunTime( ) raises (FrameworkErrorSignal);
void setRecipeEstimatedRunTime(in Duration aRunTime)
raises (FrameworkErrorSignal, SetValueOutOfRangeSignal);
/* A request to delete a MachineRecipe has failed because it did not exist or it was protected. */
exception MachineRecipeRemovalFailedSignal {MachineRecipe aMachineRecipe;};
Published Events:
/* Recipe attribute parameter(s) have changed and must inform to update
usage. */
RecipeParameterChangedEvent
Provided Services:
/* Add ProcessMachine to RecipeNamespace. */
void addProcessMachine(in ProcessMachine aProcessMachine)
raises (FrameworkErrorSignal, ProcessMachineDuplicateSignal);
/* Create a recipe in the RecipeNamespace with the given contents including the recipe body.
This method does not specify the mechanics of the creation that may involve the storage of the
recipe in a managed document repository. For detail information on the recipe contents refer to
SEMI E42.*/
MachineRecipe createRecipe(in RecipeIdentifier aRecipeIdentifier,
in Properties aMachineRecipeContent)
raises (FrameworkErrorSignal, DuplicateIdentifierSignal,
RecipeOperationFailedSignal);
/* Update an existing recipe with the given contents. The behavior of this interface is based on
business rules. This method is provided to update recipe contents in the RecipeNamespace. Its
behavior is not the same as the one used to update parameter settings in the selected recipe for
the process job. */
void updateRecipe(in MachineRecipe aMachineRecipe,
in Properties aMachineRecipeContents)
raises (FrameworkErrorSignal, RecipeProtectedSignal,
RecipeOperationFailedSignal);
/* Download a recipe from the RecipeNamespace into the Process Machine storage.*/
void downloadRecipeToMachine
(in RecipeIdentifier aRecipeIdentifier,
in ProcessMachine aProcessMachine)
raises (FrameworkErrorSignal, RecipeOperationFailedSignal,
ProcessMachineNotFoundSignal) ;
/* Upload a recipe from the Recipe Control on a specific ProcessMachine and store in the
RecipeNamespace. The creation or update of the uploaded recipe is based on business rules.*/
void uploadRecipeFromMachine
(in RecipeIdentifier aRecipeIdentifier,
in ProcessMachine aProcessMachine)
raises (FrameworkErrorSignal, RecipeNotFoundSignal,
ProcessMachineNotFoundSignal);
/* Verify the syntax of the body of a stored recipe before execution for valid parameter setting
definition included in the body of this recipe. */
boolean verifyRecipe( in RecipeIdentifier aRecipeIdentifier)
raises (FrameworkErrorSignal, RecipeOperationFailedSignal);
/* Download a recipe from the RecipeNamespace into the ProcessMachine using the specific
Properties for that ProcessMachine. */
void downloadRecipe
(in RecipeIdentifier aRecipeIdentifier,
in Properties aMachineRecipeContents)
raises (FrameworkErrorSignal, RecipeOperationFailedSignal,
RecipeOutOfDateSignal);
/* Select recipe to be used in the next process run. This is intended primarily for PMs, quals,
engineering runs, etc.*/
void selectRecipe ( in RecipeIdentifier aRecipeIdentifier)
raises (FrameworkErrorSignal, RecipeNotFoundSignal,
RecipeOperationFailedSignal);
/* Start the recipe for execution. This allows parameters settings to be updated by APC or
operator for the process job in conjunction with autostart disabled. /*
void executeRecipe ( in RecipeIdentifier aRecipeIdentifier,
in Properties aRecipeParameters)
raises (FrameworkErrorSignal, RecipeNotFoundSignal,
RecipeOperationFailedSignal);
Component
JobSupervisor
Manager
Resource Tracking
Component
informs
PM
Activity
Resource due Factory
Tracking
Supervisor
Manager
compares
PM Job with PM
interval
defines stored in
PM Document
Specification Revision
performs
assigned to
requests PMJob
Person
Published Events:
/*Inform Factory that a PMActivity is due now. */
PMActivityStateChangedEvent
Provided Services:
/* Answer the support resources for which a PM activity is due now. Returns NULL if no PM is
now due.*/
SupportResourceSequence allPMActivitiesDueNow( ) raises (FrameworkErrorSignal);
/*Find all PMActivities due for allSupportResources for which the ResourceTrackingManager is
responsible for during a designated time period.*/
PMActivitySequence allPMActivitesDuringDuration(in TimeWindow aTimeWindow)
raises (FrameworkErrorSignal, TimePeriodInvalidSignal);
/*Find all PMActivities due for allSupportResources in a particular area and for which the
ResourceTrackingManager is responsible for during a designated time period. Returns NULL if
no PM is due.*/
PMActivitySequence allAreaPMActivitesDuringDuration
(in Area anArea, in TimeWindow aTimeWindow)
raises (FrameworkErrorSignal, TimePeriodInvalidSignal);
/*Find all PMActivities due right now for allSupportResources in a particular area and for which
the ResourceTrackingManager is responsible for. Returns NULL if no PM is due.*/
PMActivitySequence allAreaPMActivitesDueNow(in Area anArea)
raises (FrameworkErrorSignal);
/*Answer the number of wafers or runs able to be processed before a PMActivity is due for a
particular SupportResource.*/
Units findNumberOfUnitsUntilPM (in SupportResource aSupportResource,
in PMSpecification aPMSpecification)
raises (FrameworkErrorSignal, SupportResourceNotAssignedSignal);
/*Answer the time before a PMActivity is due for a particular SupportResource. This may be
raw time or the internal logic may calculate the time based on the expected amount of Process
time.*/
Duration findTimeUntilPM (in SupportResource aSupportResource,
in PMSpecification aPMSpecification)
raises (FrameworkErrorSignal, SupportResourceNotAssignedSignal);
/*Answer the units processed since the last preventative maintenance task was performed.*/
Units unitsProcessedSinceLastPM (in SupportResource aSupportResource)
raises (FrameworkErrorSignal);
/*The time since the last PM, may be raw time or run time.*/
Duration timeSinceLastPM (in SupportResource aSupportResource)
raises (FrameworkErrorSignal);
/*Find all the PMActivities due now for a particular SupportResource. Returns NULL if no PM
is due.*/
PMActivitySequence allSupportResourcePMActivitiesDueNow
(in SupportResource aSupportResource)
raises (FrameworkErrorSignal, SupportResourceNotAssignedSignal);
/*Find all PMActivities due for designated time period for the paticular SupportResource*/
PMActivitySequence allPMActivitiesForPeriod
(in SupportResource aSuppportResource,
in TimeWindow aTimeWindow)
raises (FrameworkErrorSignal, SupportResourceNotAssignedSignal,
TimePeriodInvalidSignal);
Published Events:
/* A new PMSpecification has been created for this SupportResource. */
PMSpecificationCreatedEvent
Provided Services:
/*Add or remove a SupportResource from the list of SupportResources with this
PMSpecification. */
void addSupportResource(in SupportResource aSupportResource)
raises (FrameworkErrorSignal, SupportResourceDuplicateSignal);
void removeSupportResource(in SupportResource aSupportResource)
raises (FrameworkErrorSignal, SupportResourceNotAssignedSignal,
SupportResourceRemovalFailedSignal);
/* Get all PM definitions for this PM Specification Returns NULL if no PMDefinitions are
assigned. */
PMDefinitionSequence allPMDefinitions( ) raises (FrameworkErrorSignal);
Provided Services:
/* Get the SupportResources to be worked on for this PMJob. Returns NULL if no
SupportResources are assigned.*/
SupportResourceSequence getSupportResource ( ) raises (FrameworkErrorSignal);
/* Get the persons assigned to work on this PMJob Returns NULL if no Persons are assigned.*/
PersonSequence getPersons ( ) raises (FrameworkErrorSignal);
/* Get the PMActivity that spurred this PMJob. Note: This is as equivalent to the
ProcessOperationSpecification used in ProcessMachineJob. */
PMActivity getPMActivity ( ) raises (FrameworkErrorSignal);
*/
Contracted Services: None.
Dynamic Model: Same as Inherited Interface.
Machine
Group
requests process
control actions
stores short-term
control data Control
DataBase
Control
provides plugins Executor
stores
historical data
The APC Group utilizes the JobSupervision abstract interfaces to manage control activities.
Control activities are requested of this Group by dispatching a Job Request to the
ControlExecutionManager, which inherits the interface of a JobSupervisor. A specialization of
the Job interface, in the form of a ControlExecutor, is created to carry out the activities of the
requested control job.
This specification assumes that the OMG Trading Object Service [CosTrade] is utilized by the
CIM Framework. In general, this service facilitates the offering and the discovery of instances of
services of particular types. A trader is an object through which other objects can advertise their
capabilities and match their needs against advertised capabilities. Advertising a capability or
offering a service is called export. Matching against needs or discovering services is called
import. In the Process Control specification, Control Strategies include the definition of
capabilities that are required of component instances to carry out execution of those strategies.
Component instances, such as a Plugin Executor will export to the trader a service type of
PlugInExecutor and a property of Matlab, for example, if the PluginExecutor is capable of
executing Matlab plugins. The Control Executor Manager, upon initial examination or
subsequent execution of the Control Strategy, will obtain a sequence of offers or object
references to capable Plugin Executors by importing a service type of PlugInExecutor and a
constraint of Matlab. The Control Executor Manager may choose from this sequence of capable
Plugin Executor offers.
It is also assumed that the Control Management and Plugin Management components will
involve document management and versioned objects. For example, the Control Manager
manages Control Strategy objects. There may be multiple versions of a particular Control
Strategy object. The issue of how to provide version control, signoff, and effectivity are issues
that will be addressed at some point by the Specification Management Focus Team. This design
may be influenced by the OMG Product Data Management Enablers Request For Proposal
(RFP). Initial submissions to this RFP have been received and are being reviewed by the OMG.
Revised submissions are schedule for January, 1998. Subsequent Specification Management
Focus Team version control specifications will likely impact the design of this group. Until this
time, Process Control specifications do not explicitly provide document management and version
control interfaces.
Component
Manager
Plugin Plugin
manages
Manager Factory
creates, deletes
Plugin
PLUGIN MANAGEMENT
/*Provides plugin contents for this plugin for a given contents type. */
PluginContents getContentByType (in PluginContentType aPluginContentType)
raises (FrameworkErrorSignal, NoContentForTypeSignal);
/* Returns the PluginSpecification for this plugin. Among other things, it provides capabilities
required of plugin executors to execute this plugin. The control executor will obtain a capable
plugin executor by querying the trader. */
PluginDescription getDescription ( ) raises (FrameworkErrorSignal);
Component
Manager
Plugin
Plugin is executed by
Executor
PLUGIN EXECUTION
/* Executes the previously setup plugin and returns the data result. */
ControlValues executePlugin (in PluginHandle aPluginHandle,
in PerformanceData aPerformanceData)
raises (FrameworkErrorSignal,
UnableToExecuteSignal, BadPluginHandleSignal);
/* Removes the plugin and eliminates all traces of the previously setup plugin from the execution
environment. */
void unsetupPlugin (in PluginHandle aPluginHandle)
raises (FrameworkErrorSignal,
BadPluginHandleSignal, UnableToUnSetupSignal);
Component Control
Control
Manager Strategy creates
Strategy
Factory
is provided by is held by
Running
Control
selects Control
Manager
Strategy
*
provides
creates, deletes
Running
Control
Strategy
Factory
CONTROL MANAGEMENT
/* This method returns the a portion of the Contents of the ControlStrategy specified by the
ContentType. */
Contents getContentsByType (in ContentType theType)
raises (FrameworkErrorSignal, NoContentForTypeSignal);
/* This method returns the ExecutionContext that the RunningControlStrategy was started
under. */
ExecutionContext getRunningContext ( ) raises (FrameworkErrorSignal);
/* This method returns the a reference to the ControlStrategy that this RunningControlStrategy is
using. */
ControlStrategy getControlStrategy ( ) raises (FrameworkErrorSignal);
Component Job
Job
Manager Supervisor
Trader
get initial Data
references
Control Collection
Execution Plan
obtains Manager Manager
process or
Data sensor data
Collector from Running
obtains plans Control
manages from Strategy
1+
obtains control refers to
strategies from
Control
Executor
obtains plugins
from
directs
saves data
plugin
to
execution
Control Plugin
Manager Manager
Plugin
History
Executor
saves data to
and retrieves
from
Control
Database
Published Events:
/*This event is emitted upon every status change in the Executor. */
ControlExecutorStatusEvent
APCFaultEvent
Provided Services:
/* Return the ExecutionType. */
ExecutionType getExecutionType( ) raises (FrameworkErrorSignal);
/* Return ExecutionContext. */
ExecutionContext getExecutionContext( ) raises (FrameworkErrorSignal);
/* Return RunningControlStrategy. */
RunningControlStrategy getRunningControlStrategy( ) raises (FrameworkErrorSignal);
COMPONENT
MANAGER
selects
DataCollectionPlans
based on context
DataCollectionPlan
Manager
External Entity
manages
DataCollectionPlan
Factory
selects
DataCollectionPlans
based on name
DATACOLLECTIONPLAN
MANAGER
/* DataCollectionPlans are composed primarily of name/value sequences, which were chosen for
their flexibility. However, when sensors and fab tools are built (or their Machine equivalents),
specific names will have to be chosen (StartEvent v. StartEventSource). These names should be
openly distrubuted and reused as much as possible. DurationPlan – Specifies when data
collection should begin and end. Some example name-value pairs that could be used to specify
start and stop events are given in the following table:*/
/*
StartEventSource Name of object (source) that emits the start event.
Step1EventSource Source (object name) of event that triggers end of step one of a data collectin
plan.
… …
StepNEventSource Source of event that triggers end of step N of a data collectin plan.
EndEventSource Source that emits the end of data collection plan event.
*/
COMPONENT
MANAGER
CONTROL
DATABASE
MANAGER
manages
CONTROL
DATA
CONTROL DATABASE
/* Exception for a failed attempt to add data to the control database, DataTagSequence must be
unique. */
exception DataTagSequenceDuplicateSignal {DataTagSequence aDataTagSequence;};
/* Exception for a failed attempt to query data from the control database. */
exception DataNotFoundSignal {DataTagSequence tagsequence;};
/* FindControlData returns the ControlData object for which the DataTag matches exactly. */
ControlData findControlData (in DataTagSequence aDataTagSequence)
raises (FrameworkErrorSignal, BadDataTagSequenceSignal,
DataNotFoundSignal);
/* Discontinues data collection for the DataCollectionPlan(s) referenced by the DCID; all data
collected under those plans is also deleted. */
void unsetupDataCollection(in DataCollectionID aDataCollectionID)
raises (FrameworkErrorSignal, InvalidDataCollectionID );
/* Allows data collection to begin based on the start conditions specified in the
DataCollectionPlans. */
void enableDataCollection(in DataCollectionID aDataCollectionID)
raises (FrameworkErrorSignal, InvalidDataCollectionID );
/* Disables data collection to begin based on the start conditions specified in the
DataCollectionPlans. */
void disableDataCollection(in DataCollectionID aDataCollectionID)
raises (FrameworkErrorSignal, InvalidDataCollectionID );
Scheduling
Scheduling Management
Dispatching
Functional Group
provides lists of options
of immediate activity
assigns requests
provides process active lots
specifications operators
Process
Specification
Person Material
Management Management
ComponentManager Resource
Dispatching
Component
DispatchingManager
manages
Dispatcher
provides
content
information
DispatchList
contains
DispatchDecision
holds information about
activities
Published Events:
DispatchLifecycleEvent
Provided Services:
/* Create and add a Dispatcher to the set of Dispatchers managed by this manager. Return the
Dispatcher created. */
Dispatcher createDispatcher ( ) raises (FrameworkErrorSignal);
/* Remove and delete a Dispatcher from the set of Dispatchers managed by this manager. */
void removeDispatcher (in Dispatcher aDispatcher)
raises (FrameworkErrorSignal,DispatcherNotAssignedSignal,
DispatcherRemovalFailedSignal);
/* Return the Dispatcher responsible for creating ScheduledActivities for the specific object.
Raise the exception if the specific object does not have a Dispatcher defined for it. */
Dispatcher findDispatcherFor (in Resource targetObject)
raises (FrameworkErrorSignal, DispatcherNotFoundSignal);
/* An attempt was made to remove a dispatchable object that isn’t in this Dispatcher’s scope. */
exception DispatchableObjectRemovalFailedSignal { };
exception DispatchableObjectNotAssignedSignal { };
exception DispatchListRemovalFailedSignal { };
exception DispatchListNotAssignedSignal { };
/* Remove a dispatchable object from the set of dispatchable objects for which this Dispatcher
can make dispatch decisions. Raise the exception if the dispatchable object was not found. */
void removeDispatchableObject (in Resource dispatchableObject)
raises (FrameworkErrorSignal, DispatchableObjectRemovalFailedSignal,
DispatchableObjectNotAssignedSignal);
/* Delete DispatchList and all DispatchDecisions (and related ScheduledActivities) in the list. */
void deleteDispatchList (in DispatchList aDispatchList)
raises (FrameworkErrorSignal,DispatchListRemovalFailedSignal,
DispatchListNotAssignedSignal);
/* Remove a DispatchDecision from the list as indicated by the given sequence index. */
void removeDispatchDecision (in long decisionIndex)
raises (FrameworkErrorSignal, InvalidDispatchDecisionIndexSignal);
/* Choose a DispatchDecision in the list as indicated by the given sequence index. All other
DispatchDecisions and ScheduledActivities will be deleted by this method. */
void selectDispatchDecision (in long decisionIndex)
raises (FrameworkErrorSignal, InvalidDispatchDecisionIndexSignal);
/* Returns the PM activity structure that is needed for the dispatch decision.*/
PMActivity getPMActivityInformation ( ) raises (FrameworkErrorSignal);
requests
requests manual processing to identify/assign qualified/
material movement be performed available person to
perform a job
Factory Labor
Person
Skill
Management
Management
compare personnel
medical / training history
with skill requirements
assigns person to
define skills
shift(s) / area(s) /
requests personnel to needed for
machine(s)
perform PMs for capability
support resources
Process
Factory Machine
Capability
Management Group
Manager
has a
Person
Management
Component PersonManager
creates and
manages
qualifications
to perform
factory
operations are
defined
by Area
QualificationData Person assigned
to
has assigned
to
Machine
assigned
to
Skill Job
/* This signal is raised when a retrieval operation fails because the Person specified by the
argument could not be located. */
exception PersonNotFoundSignal {string identificationNumber;};
/* This signal is raised when a removal operation fails because the Person specified by the
argument is not assigned to the PersonManager. */
exception PersonNotAssignedSignal {Person unknownPerson;};
exception PersonRemovalFailedSignal { };
Published Events:
PersonLifecycleEvent
Provided Services:
/* Create an instance of Person with a unique identifier and add to the list managed by
PersonManager. */
Person createPersonWithIdentifier (in string identificationNumber)
raises (FrameworkErrorSignal, PersonDuplicateSignal);
/* Delete the Person identified by the argument from the list managed by PersonManager. */
void removePerson (in Person aPerson)
raises (FrameworkErrorSignal,PersonRemovalFailedSignal,
PersonNotAssignedSignal);
/* Search for an instance of Person using its unique identifier. Raises an exception if the Person
is not found. */
Person findByIdentifier (in string identificationNumber)
raises (FrameworkErrorSignal, PersonNotFoundSignal);
/* Return a set of Persons available (on duty on the current shift) to operate the specified
machine. This service assumes that a Person is qualified to operate the machine. */
PersonSequence allPersonsAvailableForMachine (in Machine aMachine)
raises (FrameworkErrorSignal);
/* Return a set of Persons available (on duty on the current shift) to perform a process or material
movement job. This service assumes that a Person is qualified to perform the job. */
PersonSequence allPersonsAvailableForJob (in Job aJob)
raises (FrameworkErrorSignal);
/* This signal is raised when a removal operation fails because the Qualification specified by the
argument could not be located. */
exception QualificationNotAssignedSignal {string identificationNumber;};
/* This signal is raised when a retrieval operation fails because the Qualification specified by the
argument could not be located. */
exception QualificationNotFoundSignal {string identificationNumber;};
/* This signal is raised when an addition operation fails because the Responsibility specified by
the argument already exists. */
exception ResponsibilityDuplicateSignal {any responsibility ;
string responsibilityCategory;};
/* This signal is raised when an operation fails because the Responsibility category specified by
the argument could not be located. */
exception ResponsibilityCategoryNotFoundSignal {
string responsibilityCategory;};
exception ResponsibilityCategoryRemovalFailedSignal { };
/* This signal is raised when a removal operation fails because the Responsibility specified by
the argument could not be located. */
exception ResponsibilityRemovalFailedSignal {
any responsibility;
string responsibilityCategory;};
/* This signal is raised when an addition operation fails because the skill specified by the
argument already exists. */
exception SkillDuplicateSignal {Skill aSkill;};
/* This signal is raised when a removal operation fails because the skill specified by the argument
could not be located. */
exception SkillRemovalFailedSignal {Skill aSkill;};
exception SkillNotAssignedSignal {Skill aSkill;};
exception SkillNotFoundSignal {Skill aSkill;};
Published Events:
/* This event is posted when a Person’s capacity to do work has changed.
This includes assignment to/deassignment from machines and jobs. It also
includes the changing the number of jobs and/or machines to which a
Person may be assigned. */
PersonCapacityChangedEvent
Provided Services:
/* Set and get the Person’s department. */
void setDepartment (in string department)
raises (SetValueOutOfRangeSignal, FrameworkErrorSignal);
string getDepartment ( ) raises (FrameworkErrorSignal);
/* Set and get the maximum the number of jobs to which a Person can be assigned
simultaneously. */
void setMaximumAssignedJobs (in long maximumJobs)
raises (SetValueOutOfRangeSignal, FrameworkErrorSignal);
long getMaximumAssignedJobs ( ) raises (FrameworkErrorSignal);
/* Set and get the maximum number of machines to which a Person can be assigned
simultaneously. */
void setMaximumAssignedMachines (in long maximumMachine)
raises (SetValueOutOfRangeSignal, FrameworkErrorSignal);
long getMaximumAssignedMachines ( ) raises (FrameworkErrorSignal);
/* Add an object within the factory to a Person’s responsibility category. The concept of
responsibility implies that a Person is authorized to perform, operate or access the factory object.
It does not imply ownership. The first argument represents the responsibility (object within the
factory) which is associated with a responsibility category, while the second argument is the
category. If the specified category does not exist, it is created. The service returns the added
factory object.
For example, add a machine to the Person’s maintenance responsibilities category. Another
example: add a change notice to a Person’s signoff responsibility category. */
any addResponsibility_toCategory (in any responsibility,
in string responsibilityCategory)
raises (FrameworkErrorSignal, ResponsibilityDuplicateSignal,
ResponsibilityCategoryNotFoundSignal );
/* Remove an object within the factory from a Person’s responsibility category. If the specified
category, or responsibility does not exist, then an exception is raised. */
void removeResponsibility_fromCategory (in any responsibility,
in string responsibilityCategory)
raises (FrameworkErrorSignal, ResponsibilityRemovalFailedSignal,
ResponsibilityCategoryRemovalFailedSignal);
/* Return the responsibilities (objects within a factory) that are assigned to a Person's
responsibility category. For example, return all of the specifications in the category specification
management. A dictionary of key/value pairs is returned that represents these responsibility
associations. The key is the responsibility category name while the value is the set of factory
objects associated with that category. */
ResponsibilitySequence responsibilities ( ) raises (FrameworkErrorSignal);
/* Add the skill (qualification to operate a specific machine) to the Person’s list of skills. Skills
may be assigned or obtained through the completion of specified course (s) and medical
examination (s). This service does not detail specific course and medical examination
requirements. */
void addSkill (in Skill aSkill)
raises (FrameworkErrorSignal, SkillDuplicateSignal);
/* Add the specified qualification (training course or medical examination) data to the training or
medical history of a Person. */
void addQualification (in QualificationData qualificationInformation)
raises (FrameworkErrorSignal, QualificationDuplicateSignal);
/* Remove the specified qualification data from the training or medical history of a Person. */
void removeQualification (in QualificationData qualificationInformation)
raises (FrameworkErrorSignal, QualificationNotAssignedSignal);
/* Return the sequence of process capabilities which this Person is qualified to perform. */
CapabilitySequence processCapabilities ( ) raises (FrameworkErrorSignal);
/* Denote that this has logged off of the current shift and is NOT AVAILABLE. */
void makeOffShift ( ) raises (FrameworkErrorSignal);
/* Denote that this Person is at a work station and available for work. It is required that the
Person has logged on to the current shift. Assignment to machine (s) and/or job (s) may or may
not have occurred. */
void makeAtWorkStation ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal );
/* Denote that this Person is not immediately available at a work station and cannot perform
work. An example of this condition is an operator taking a personal break during a shift. */
void makeNotAtWorkStation ( )
raises (FrameworkErrorSignal, InvalidStateTransitionSignal );
/* Return a boolean denoting whether or not a Person is logged on to the current shift. */
boolean isOnShift ( ) raises (FrameworkErrorSignal);
/* Return a boolean denoting whether or not a Person is qualified for any machine. */
boolean hasSkills ( ) raises (FrameworkErrorSignal);
/* Return a boolean denoting whether or not a Person is available for the specified machine. */
boolean isAvailableForMachine (in Machine aMachine) raises (FrameworkErrorSignal);
/* Assign a Person to a machine. A Person may be assigned to more than one machine. */
void assignToMachine (in Machine aMachine) raises (FrameworkErrorSignal);
/* Return a boolean denoting whether or not a Person is assigned to the specified machine. */
/* Return a boolean denoting whether or not a Person is qualified for any job. */
boolean isQualifiedForJobs ( ) raises (FrameworkErrorSignal);
/* Return a boolean denoting whether or not a Person is available for the specified job. */
boolean isAvailableForJob (in Job aJob) raises (FrameworkErrorSignal);
/* Assigns a Person to a job. A Person may be allocated to more than one job at a time. */
void assignToJob (in Job aJob) raises (FrameworkErrorSignal);
/* Return a boolean denoting whether or not a Person is assigned to the specified job. */
boolean isAssignedToJob (in Job aJob) raises (FrameworkErrorSignal);
/* Return a boolean denoting whether or not a Person is available for more jobs. */
boolean isAvailableForMoreJobAssignments ( ) raises (FrameworkErrorSignal);
Dynamic Model:
Person
NOT AVAILABLE
1 12
AVAILABLE
UNASSIGNED
TO MACHINES
UNASSIGNED
TO JOBS
4 7
8
ASSIGNED 11
AT WORK TO ASSIGNED
STATION MACHINES TO JOBS
2 3
AVAILABLE AVAILABLE
FOR MORE FOR MORE
ASSIGNMENTS ASSIGNMENTS
NOT
AT WORK 9
5 6 10
STATION
ASSIGNMENT ASSIGNMENT
AT CAPACITY AT CAPACITY
EXCEEDED EXCEEDED
PersonStateChanged
event posted by
instance of Person.
MESFactory ComponentManager
has
Skill
define(s) the Management
qualification SkillManager
for performing
Component
a
ProcessCapability manages
Skill
has
Person is achieved
by satisfying
performs SkillRequirement
Job
/* This signal is raised when a removal operation fails because the Skill specified by the
argument could not be located. */
exception SkillNotAssignedSignal {string skillName;};
exception SkillRemovalFailedSignal {string skillName;};
/* This signal is raised when a retrieval operation fails because the Skill specified by the
argument could not be found. */
exception SkillNotFoundSignal {string skillName;};
/* Search for an instance of Skill using its name. Raises an exception if the Skill is not found. */
Skill findSkillNamed (in string skillName)
raises (FrameworkErrorSignal, SkillNotFoundSignal );
/* This signal is raised when a removal operation fails because the SkillRequirement specified by
the argument could not be located. */
exception SkillRequirementRemovalFailedSignal {SkillRequirement aRequirement;};
/* This signal is raised when a retrieval operation fails because the SkillRequirement specified by
the argument could not be located. */
exception SkillRequirementNotFoundSignal {string requirementName;};
/* Define a training course or medical examination necessary for obtaining an instance of Skill.
*/
SkillRequirement createSkillRequirementNamed (in string requirementName)
raises (FrameworkErrorSignal, SkillRequirementDuplicateSignal);
/* Search for an instance of SkillRequirement using its name. Raises an exception if the
SkillRequirement is not found. */
SkillRequirement findSkillRequirementNamed (in string requirementName)
raises (FrameworkErrorSignal, SkillRequirementNotFoundSignal);
/* List the training course or medical examination requirements that must be completed in order
to be qualified for an instance of Skill. */
RequirementSequence requirements ( ) raises (FrameworkErrorSignal);
/* Set and get the requirement descriptor. (An abbreviated string which serves as a “short-hand”
notation for identifying a training course or examination; e.g., “OPS-ORIENT-1”). */
void setDesignator (in string designator) raises (FrameworkErrorSignal);
string getDesignator ( ) raises (FrameworkErrorSignal);
/* Set and get the required training course grade which must be received or medical examination
result which must be achieved for the requirement. */
void setRequiredResult (in string result) raises (FrameworkErrorSignal);
string getRequiredResult ( ) raises (FrameworkErrorSignal);
/* Return the information pertaining to the period of time in which this requirement is in effect.
The information includes a starting time and a duration, from which expiration date can be
computed. */
TimeWindow effectivity ( ) raises (FrameworkErrorSignal);
APPENDIX A
Glossary
Abstract class: Class that has no instances. An abstract class is written with the expectation that
its subclasses will add to its structure and behavior.
Abstract interface: An interface that is not instantiable and that standarizes the interfaces for a
concrete implementation of the interface.
Abstraction: A significant concept, function, or service provided by a subsystem. The essential
characteristics of an object that distinguish it from all other kinds of objects and thus provide
crisply-defined conceptual boundaries relative to the perspective of the viewer. The process of
factoring common behavior exhibited by one or more types to a separate super-type with the
intention of reusing that behavior through inheritance. The quality criteria concerned with those
software characteristics that determine how well an object, class, mechanism, service, or
subsystem capture the underlying essential characteristics of its behavior appropriate to the
requirements
Application: Functionality provided by one or more programs consisting of a collection of
interoperating objects.
Application framework: A framework that constitutes a generic application for a domain area.
Application Interface: A nonstandardized, application-specific interface.
Application object: An object implementing an Application Interface.
Architecture: The structure of the components of a program/system, their interrelationships, and
principles and guidelines governing their design and evolution over time.
Attribute: An identifiable association between an object and a value. An attribute may have
accessor functions to set and retrieve its value.
Behavior: The observable effects of performing a requested service including its results.
Binding: A specific choice of platform technologies and other implementation-specific criteria.
Change notice: A procedural tool employed in typical factories for initiating and specifying
change(s) to document(s) whose versions are controlled.A change notice is usually associated
with change approval and change activation processes as well.In a factory, change notices may be
of paper or electronic form. Electronic change notices are supported by a software application.
The CIM Framework supports such applications by providing standard change notice behavior
and functionality embodied in the Version Management Component.
CIM: Acronym for Computer Integrated Manufacturing. An approach that leverages the
information handling capability of computers to manage manufacturing information and support
or automate the execution of manufacturing operations.
Class: The shared common structure and common behavior of a set of objects. The definition of
an object type. In CORBA IDL of the CIM Framework, classes are specified using the interface
keyword, and superclass/subclass relationships are specified using the inherited interface
keyword.
Method: An operation upon an object defined as part of the declaration of a class. In general, the
terms message, method and operation can be used interchangeably. Technically, a method is
defined within a class and an operation is defined within the IDL. An operation is implemented
by a method.
Method binding: The selection of the method to perform a requested service.
Object: An identifiable encapsulated entity that implements one or more services that can be
requested by a client. An instance of a class.
Object diagram: Part of the notation of object-oriented design that is used to show the existence
of objects and their relationships in the logical design of a system and that primarily illustrates
the semantics of key mechanisms in the logicaldesign.
Object oriented analysis: A method of analysis in which requirements are examined from the
perspective of the classes and objects found in the vocabulary of the problem domain.
Object oriented design: A method of design encompassing the process of object-oriented
decomposition and a notation for depicting both logical and physical as well as static and
dynamic models of the system under design. This notation includes class diagrams, object
diagrams, module diagrams, and process diagrams.
Object oriented programming: A method of implementation in which programs are organized
as cooperative collections of objects, each of which represents an instance of some class and
whose classes are all members of a hierarchy of classes united through inheritance relationships.
In such programs, classes are generally viewed as static, whereas objects typically have a much
more dynamic nature.
Object system: An object system is a collection of objects that isolates the requesters of services
from the providers of services by a well-defined encapsulating interface. In particular, clients are
isolated from the implementation of services as data representations and executable code.
OMA: Acronym for Object Management Architecture, an architecture for distributed object
computing developed by the OMG.
OMG: Acronym for Object Management Group, an international consortium dedicated to the
development of open specifications for distributed, heterogeneous, object-oriented systems.
Operation: An operation is an entity, identified by an operation identifier that denotes a service
that can be requested. An operation has a signature that describes the legitimate values of request
parameters and returned results, including any exceptions.
ORB: Acronym for Object Request Broker, which is the fundamental object communication
mechanism in the OMG Object Management Architecture.
Persistent object: An object that can survive the process or thread that created it.
Polymorphism: The ability to substitute objects of matching interfaces for another at run-time.
Process definition: As used in this specification, information related to manufacturing
processess. This information includes an estimate for the time a process resource will be engaged
in the process; process resource settings; and the process capabilities required for the process.
Process flow: The part of a product specification that defines the sequence of process steps for
the manufacturing of a specific product. The data structure for representing a process flow is the
directed graph; specifically, a tree structure. The nodes of the tree are called process flow nodes
(see below). Services are required to navigate the process flow.
Process flow context: Navigational information pertaining to a product’s progress as it traverses
its context process flow.
Process flownode: A data structure element (a node) within a directed graph which is used by a
specification management system to represent a process flow. A process flow node corresponds
to a point along a process flow where processing is defined. An operation set specification is a
type of process flow node.
Process sequence node: A data structure element (a node) within a directed graph representing
material routing. A set of linked process sequence nodes describes the routing of a material
within a machine.
Process step: The smallest unit of processing activity which can be defined in a process flow.
One or more process steps are sequenced to define an operation set.
Recipe: The pre-planned and reusable portion of the set of instructions, settings and parameters
that determine how a job is to be performed.For example, recipes are used to describe
ProcessSteps and are typically contained within a ProductSpecification. They determine the
processing environment seen by a manufactured product (e.g., wafer). Processing recipes may be
subject to change between product runs or processing cycles.
Server object: An object providing a response to a request for service.
Signature: A signature is the name, parameters, return values and exceptions for a specific
operation.
Standard: A component specification subscribed to by the consensus of implementers of the
CIM Framework under control of the appropriate governing body and subject to document
revision.
Substitutability: The ability to replace a given component from one supplier with a functionally
equivalent component from another supplier without impacting the other components or its
clients in the system.
Thread of control: (control thread) A single, sequential flow of control within a computer
program. Some operating systems support the simultaneous execution of control threads in
parallel. A thread of control may represent the functionality of a sub-task within a larger task. For
example, a factory startup task might initiate several threads of control, each of which is
responsible for the startup of a particular piece of processing equipment.
Validation: A continuing process to ensure that requirements at various levels are correct, thus
satisfying project requirements.
Version managed revision: A change (revision) of a document which requires the application of
special practices in order to manage the approval and activation (use) of the change.For example,
a document specifying exact equipment settings for performing a process on military grade
APPENDIX B
Acronyms
APPENDIX C
References
[Alb] Albus, J.S. “Outline for a Theory of Intelligence,” IEEE (Institute of Electrical
and Electronics Engineers) Transactions on Systems, Man, and Cybernetics 21,
n3 p473-509 May/Jun 91.
[Boo91] Booch, G. Objected-Oriented Design with Applications, Benjamin Cummings,
1991.
[CIMArch] Computer Integrated Manufacturing (CIM) Framework Architecture Concepts,
Principles and Guidelines, Version 1.0, Technology Transfer #97103379A-ENG.
Austin, TX: SEMATECH.
[ComFac] Object Management Group. Common Facilities Architecture, Revision 4.0.
Document Number 95-01-02. Framingham, MA: Object Management Group,
1995.
[CORBA] Object Management Group. Common Object Request Broker: Architecture and
Specification, Revision 2.1. Framingham, MA: Object Management Group, 1997.
ftp://ftp.omg.org/pub/docs/formal/97-10-01.pdf.
[COS] Object Management Group. CORBAservices: Common Object Services
Specification. Framingham, MA: Object Management Group, November 22,
1996.
[CosEvent] Object Management Group. CORBAservices - Event Management Service.
Document Number 97-07-13. Framingham, MA: Object Management Group,
1997. ftp://ftp.omg.org/pub/docs/formal/97-07-13.pdf.
[CosProp] Object Management Group. CORBAservices - Property Service. Document
Number 97-07-22. Framingham, MA: Object Management Group, 1997.
ftp://ftp.omg.org/pub/docs/formal/97-07-22.pdf.
[CosTime] Object Management Group. Object Time Service Specification. Document
Number 97-07-25. Framingham, MA: Object Management Group, 1997.
ftp://ftp.omg.org/pub/docs/ab/97-07-25.pdf.
[CosTrade] Object Management Group. CORBAservices - Trader Service. Document Number
97-07-26. Framingham, MA: Object Management Group, 1997.
ftp://ftp.omg.org/pub/docs/formal/97-07-26.pdf.
[Gam94] Gamma, Eric, et. al., Design Patterns: elements of resuable object-oriented
software. Reading, MA. Addison-Wesley, 1994.
[Haw] Hawker, J.S., An Organization for Intelligent Robot Control, Ph.D. Dissertation,
Lehigh University, Bethlehem, Pennsylvania, 1990.
[ISA] Standard ISA-S88.01 - Batch Control, Part 1: Models and Terminology,
Instrument Society of America, Research Triangle Park, North Carolina, 1995.
APPENDIX D
CIM Framework Events
Job
/* Job state change event definition. */
#define JobStateChangedSubject “/JobManagement/Job/StateChanged”
enum JobState { JobUndefined, JobCreated, JobQueued, JobCancelled, JobActive,
JobExecuting, JobNotPaused, JobPausing, JobPaused, JobNotStopping, JobStopping,
JobNotAborting, JobAborting, JobFinished, JobCompleted, JobStopped, JobAborted };
typedef struct JobStateChangedFilter_Structure {
Property name; // “Name”, aJob’s name
Property formerState; // “FormerState”, JobState
Property newState; // “NewState”, JobState
} JobStateChangedFilters;
typedef struct JobStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
JobStateChangedFilters eventFilterData;
Properties eventNews;
Job aJob;
} JobStateChangedEvent;
MESFactory
/* MES Factory state change event definition. */
2
The use of “name” here (and in all other events) indicates the string value for the name or identifier of the object to which the event refers.
Since filtering does not support object reference comparisons, the filtering must be on the “name” of the object. Since all events are about
objects that inherit from NamedEntity, they all have names. In some cases, such as Lot, the object has a defined unique identifier. In those
cases, the identifier attribute should be used rather than the name from NamedEntity inheritance.
Area
/* Area configuration changed event definition. */
#define AreaConfigurationChangedSubject “/Factory/Area/AreaConfigurationChanged”
enum AreaChangeType { MachinesChanged, PersonsChanged, SubAreaChanged };
typedef struct AreaConfigurationChangedFilter_Structure {
Property name; // “Name”, anArea’s name
Property changeType; //“ChangeType”, AreaChangeType
} AreaConfigurationChangedFilters;
typedef struct AreaConfigurationChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
AreaConfigurationChangedFilters eventFilterData;
Properties eventNews;
Area anArea;
} AreaConfigurationChangedEvent;
FactoryCalendar
/* Area shutdown changed event definition. */
#define AreaShutdownChangedSubject “/Factory/FactoryCalendar/AreaShutdownChanged”
typedef struct AreaShutdownChangedFilter_Structure {
Property name; // “Name”, anArea’s name
Property shutdownDate; //“ShutdownDate”, TimeStamp for new shutdown
} AreaShutdownChangedFilters;
typedef struct AreaShutdownChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
AreaShutdownChangedFilters eventFilterData;
Properties eventNews;
Area anArea;
} AreaShutdownChangedEvent;
Component Manager
/* Component Manager state changed event definition. */
Product Manager
/* Process group lifecycle event definition. */
#define ProcessGroupLifecycleSubject
“/ProductManagement/ProductManager/ProcessGroupLifecycle”
typedef struct ProcessGroupLifecycleFilter_Structure {
Property name; // “Name”, aProcessGroup’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} ProcessGroupLifecycleFilters;
typedef struct ProcessGroupLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ProcessGroupLifecycleFilters eventFilterData;
Properties eventNews;
ProcessGroup aProcessGroup;
} ProcessGroupLifecycleEvent;
Lot
/* Lot state change event definition. */
#define LotStateChangedSubject “/ProductManagement/Lot/StateChanged”
enum LotState { LotUndefined, LotCreated, LotReleased, LotActive, LotInProduction,
LotInRework, LotOnHold, LotNotOnHold, LotWaitingToLogin, LotLoggedIn, LotLoggedOut,
LotFinished, LotCompleted, LotEmptied, LotScrapped, LotShipped };
typedef struct LotStateChangedFilters_Structure {
Property name; // “Name”, aLot’s name
Property formerState; // “FormerState”, LotState
Property newState; // “NewState”, LotState
} LotStateChangedFilters;
typedef struct LotStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
LotStateChangedFilters eventFilterData;
Properties eventNews;
Lot aLot;
} LotStateChangedEvent;
/* Lot quantity change event definition. This event is posted when a Lot’s quantity of Product as
changed due to scrap, loss, splits or joins. */
#define LotQuantityChangedSubject “/ProductManagement/Lot/QuantityChanged”
/* Lot priority change event definition. This event is posted whenever a Lot’s priority changes. */
#define LotPriorityChangedSubject “/ProductManagement/Lot/PriorityChanged”
typedef struct LotPriorityChangedFilters_Structure {
Property name; // “Name”, aLot’s name
Property formerPriority;
// “FormerPriority”, aLot’s former priority
Property newPriority; // “NewPriority”, aLot’s new priority
} LotPriorityChangedFilters;
typedef struct LotPriorityChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
LotPriorityChangedFilters eventFilterData;
Properties eventNews;
Lot aLot;
} LotPriorityChangedEvent;
/* Lot flow position adjusted event definition. This event is posted when a Lot is adjusted in its
flow position. This event is not necessary when the flow position adjustment is in its normal,
next sequential operation but only when the Lot is adjusted to a radically differenct position in
the flow (usually due to an engineering decision about rework). */
/* Lot process flow changed event definition. This event is posted when a Lot is moved to a
different ProcessFlow from its current ProcessFlow. This can occur because a given Lot has
failed some sort of inspection and will become a downgraded product type or because a Lot is
moved onto a different rework flow. Typically, when a Lot is split, it is so that part of the Product
of the Lot can move onto a different flow temporarily and eventually be joined back to the
original Lot for continued processing on the “normal” flow. */
#define LotProcessFlowChangedSubject “/ProductManagement/Lot/ProcessFlowChanged”
typedef struct LotProcessFlowChangedFilters_Structure {
Property lotName; //“LotName”,value = aLot’s name
Property oldProcessFlowName; // “OldProcessFlowName”,
// aLot’s old ProcessFlow’s name
Property newProcessFlowName; // “NewProcessFlowName”,
//aLot’s new ProcessFlow’s name
Property theProcessStepName; // “ProcessStep”,
//aLot’s new ProcessStep’s name
} LotProcessFlowChangedFilters;
typedef struct LotProcessFlowChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
LotProcessFlowChangedFilters eventFilterData;
Properties eventNews;
Lot aLot;
// ProcessFlow oldProcessFlow;
// ProcessFlow newProcessFlow;
// ProcessStep newProcessStep;
} LotProcessFlowChangedEvent;
/* Lot reservation changed event. This event is posted when a Lot is placed on reserve by some
entity or when a reservation is removed. When a Lot is reserved, it should no longer be
considered for dispatching decisions. */
#define LotReservationChangedSubject “/ProductManagement/Lot/ReservationChanged”
typedef struct LotReservationChangedFilters_Structure {
Property name; // “Name”, aLot’s name
Property state; //“ReservationState”, aLot’s reservation state
Property reservingObjectName; // “ReservingObjectName”,
Durable Manager
/* TransportGroup lifecycle event definition. */
#define TransportGroupLifecycleSubject
“/DurableManagement/DurableManager/TransportGroupLifecycle”
typedef struct TransportGroupLifecycleFilters_Structure {
Property name; // “Name”, aTransportGroup’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} TransportGroupLifecycleFilters;
typedef struct TransportGroupLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
TransportGroupLifecycleFilters eventFilterData;
Properties eventNews;
TransportGroup aTransportGroup;
// Except when “Delete” where value will be nil
} TransportGroupLifecycleEvent;
TimeStamp eventTimeStamp;
ProcessDurableLifecycleFilters eventFilterData;
Properties eventNews;
ProcessDurable aProcessDurable;
// Except when “Delete” where value will be nil
} ProcessDurableLifecycleEvent;
Durable
/* Durable state change event definition. */
#define DurableStateChangedSubject “/DurableManagement/Durable/StateChanged”
enum DurableState {DurableUndefined, DurableAvailable, DurableNotAvailable,
DurableInUse, DurableScrapped };
typedef struct DurableStateChangedFilters_Structure {
Property name; // “Name”, aDurable’s name
Property formerState; // “formerState”, DurableState
Property newState; // “newState”, DurableState
} DurableStateChangedFilters;
typedef struct DurableStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
DurableStateChangedFilters eventFilterData;
Properties eventNews;
Durable aDurable;
} DurableStateChangedEvent;
/* Durable reservation changed event. This event is posted when a Durable is placed on reserve
by some entity or when a reservation is removed. */
#define DurableReservationChangedSubject
“/DurableManagement/Durable/ReservationChanged”
typedef struct DurableReservationChangedFilters_Structure {
Property durableName; // “DurableName”, aDurable’s name
Property state; // “ReservationState”, ReservationState
Property reservingObjectName;
//“ReservingObjectName”,reserving object’s name
} DurableReservationChangedFilters;
typedef struct DurableReservationChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
DurableReservationChangedFilters eventFilterData;
Properties eventNews;
Durable aDurable;
any ReservingObject;
} DurableReservationChangedEvent;
Consumable Manager
/* Consumable lifecycle event definition. */
#define ConsumableLifecycleSubject
“/ConsumableManagement/ConsumableManager/ConsumableLifecycle”
typedef struct ConsumableLifecycleFilters_Structure {
Property name; // “Name”, aConsumable’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} ConsumableLifecycleFilters;
typedef struct ConsumableLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ConsumableLifecycleFilters eventFilterData;
Properties eventNews;
Consumable aConsumable; // Except when “Delete” where
value will be nil
} ConsumableLifecycleEvent;
Consumable
/* Consumable depletion and addition event definition. */
#define ConsumableStateChangedSubject “/ConsumableManagement/Consumable/ConsumableStateChanged”
enum ConsumableState { ConsumableUndefined, ConsumableAvailable, ConsumableDepleted };
typedef struct ConsumableStateChangedFilters_Structure {
Property name; // “Name”, aConsumable’s name
Property state; // “NewState”, ConsumableState
} ConsumableStateChangedFilters;
typedef struct ConsumableStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ConsumableStateChangedFilters eventFilterData;
Properties eventNews;
Consumable aConsumable;
} ConsumableStateChangedEvent;
ConsumableQuantityChangedFilters eventFilterData;
Properties eventNews;
Consumable aConsumable;
} ConsumableQuantityChangedEvent;
Document Manager
/* Document lifecycle event definition. */
#define DocumentLifecycleSubject
“/DocumentManagement/DocumentManager/DocumentLifecycle”
typedef struct DocumentLifecycleFilters_Structure {
Property name; // “Name”, aDocumentSpecification’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} DocumentLifecycleFilters;
typedef struct DocumentLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
DocumentLifecycleFilters eventFilterData;
Properties eventNews;
DocumentSpecification aDocumentSpecification;
// Except when “Delete” where value will be nil
} DocumentLifecycleEvent;
Document Specification
/* Document Revision lifecycle event definition. */
#define DocumentRevisionLifecycleSubject
“/DocumentManagement/DocumentSpecification/DocumentRevisionLifecycle”
typedef struct DocumentRevisionLifecycleFilters_Structure {
Property name; // “name”, aDocumentRevision’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} DocumentRevisionLifecycleFilters;
typedef struct DocumentRevisionLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
DocumentRevisionLifecycleFilters eventFilterData;
Properties eventNews;
DocumentRevision aDocumentRevision;
// Except when “Delete” where value will be nil
} DocumentRevisionLifecycleEvent;
Document Revision
/* Document Revision state changed event definition. */
#define DocumentRevisionStateChangedSubject
“/DocumentManagement/DocumentRevision/StateChanged”
enum DocumentRevisionState { DocumentRevisionUndefined, DocumentRevisionInWork,
DocumentRevisionActive, DocumentRevisionInactive };
typedef struct DocumentRevisionStateChangedFilters_Structure {
Property name; // “Name”, aDocumentRevision’s name
Property formerState; // “formerState”, DocumentRevisionState
Property newState; // “newState”, DocumentRevisionState
} DocumentRevisionStateChangedFilters;
typedef struct DocumentRevisionStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
DocumentRevisionStateChangedFilters eventFilterData;
Properties eventNews;
DocumentRevision aDocumentRevision;
} DocumentRevisionStateChangedEvent;
Version Manager
/* Change Notice lifecycle event definition. */
#define ChangeNoticeLifecycleSubject
“/VersionManagement/VersionManager/ChangeNoticeLifecycle”
typedef struct ChangeNoticeLifecycleFilters_Structure {
Property name; // “Name”, aChangeNotice’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} ChangeNoticeLifecycleFilters;
typedef struct ChangeNoticeLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ChangeNoticeLifecycleFilters eventFilterData;
Properties eventNews;
ChangeNotice aChangeNotice;
// Except when “Delete” where value will be nil
} ChangeNoticeLifecycleEvent;
Change Notice
/* Change Notice state changed event definition. */
#define ChangeNoticeStateChangedSubject “/VersionManagement/ChangeNotice/StateChanged”
enum ChangeNoticeState {ChangeNoticeUndefined, ChangeNoticeInWork,
ChangeNoticeActivated, ChangeNoticePreparingToActivate };
typedef struct ChangeNoticeStateChangedFilters_Structure {
Property name; // “Name”, aChangeNotice’s name
Property formerState; // “formerState”, ChangeNoticeState
Property newState; // “newState”, ChangeNoticeState
} ChangeNoticeStateChangedFilters;
typedef struct ChangeNoticeStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ChangeNoticeStateChangedFilters eventFilterData;
Properties eventNews;
ChangeNotice aChangeNotice;
} ChangeNoticeStateChangedEvent;
/* Rejected Change Notice event definition. This event is published when the change notice is
undergoing signoff validation and is rejected by one of the participants in the review process. */
#define ChangeNoticeRejectedSubject “/VersionManagement/ChangeNotice/Rejected”
typedef struct ChangeNoticeRejectedFilters_Structure {
Property name; // “Name”, aChangeNotice’s name
} ChangeNoticeRejectedFilters;
typedef struct ChangeNoticeRejectedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ChangeNoticeRejectedFilters eventFilterData;
Properties eventNews;
ChangeNotice aChangeNotice;
} ChangeNoticeRejectedEvent;
Machine Manager
/* Machine lifecycle event definition. */
#define MachineLifecycleSubject “/MachineManagement/MachineManager/MachineLifecycle”
enum MachineType{ ProcessMachineType, StorageMachineType, TransportMachineType };
typedef struct MachineLifecycleFilters_Structure {
Property name; // “Name”, aMachine’s name
Property typeOfMachine; // “MachineType”, MachineType
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} MachineLifecycleFilters;
typedef struct MachineLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
MachineLifecycleFilters eventFilterData;
Properties eventNews;
Machine aMachine;
} MachineLifecycleEvent;
Machine
/* Port available event definition. */
#define PortAvailableSubject “/MachineManagement/Machine/PortAvailable”
typedef struct PortAvailableFilters_Structure {
Property machineName; // “MachineName”, aMachine’s name
Property locationName;
// “MaterialTrackingLocationName”,
// MaterialTrackingLocation’s name
} PortAvailableFilters;
typedef struct PortAvailableEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
PortAvailableFilters eventFilterData;
Properties eventNews;
Machine aMachine;
MaterialTrackingLocation aMaterialTrackingLocation;
} PortAvailableEvent;
} MachineReservationChangedFilters;
typedef struct MachineReservationChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
MachineReservationChangedFilters eventFilterData;
Properties eventNews;
Machine aMachine;
any reservingObject;
} MachineReservationChangedEvent;
Process Machine
/* Process Run Size changed event definition. */
#define ProcessRunSizeChangedSubject
“/MachineManagement/Machine/ProcessRunSizeChanged”
typedef struct ProcessRunSizeChangedFilters_Structure {
Property name; // “Name”, aMachine’s name
} ProcessRunSizeChangedFilters;
typedef struct ProcessRunSizeChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ProcessRunSizeChangedFilters eventFilterData;
Properties eventNews;
Machine aMachine;
} ProcessRunSizeChangedEvent;
Machine Resource
/* Machine Resource E10 state changed event definition. */
#define MachineResourceE10StateChangedSubject
“/MachineManagement/MachineResource/E10StateChanged”
typedef struct MachineResourceE10StateChangedFilters_Structure {
Property name; // “Name”, aMachineResource’s name
Property formerState; // “FormerState”, E10State
Property newState; // “NewState”, E10State
} MachineResourceE10StateChangedFilters;
typedef struct MachineResourceE10StateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
MachineResourceE10StateChangedFilters eventFilterData;
Properties eventNews;
MachineResource aMachineResource;
} MachineResourceE10StateChangedEvent;
/* Machine Resource state changed event definition. */
#define MachineResourceStateChangedSubject
“/MachineManagement/MachineResource/StateChanged”
enum MachineResourceState {MachineUndefined, MachineInitializing, MachineWaiting,
MachineActive, MachineExecuting, MachineNotPaused, MachinePausing, MachinePaused,
MachineNotStopping, MachineStopping, MachineNotAborting, MachineAborting };
typedef struct MachineResourceStateChangedFilters_Structure {
Property name; // “Name”, aMachineResource’s name
Property formerState; // “formerState”, MachineResourceState
Property newState; // “newState”, MachineResourceState
} MachineResourceStateChangedFilters;
typedef struct MachineResourceStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
MachineResourceStateChangedFilters eventFilterData;
Properties eventNews;
MachineResource aMachineResource;
} MachineResourceStateChangedEvent;
ProcessResource
/* Process Resource ProcessCapability Changed event definition. */
#define ProcessResourceProcessCapabilityChangedSubject
“/MachineManagement/ProcessResource/ProcessCapabilityChanged”
enum ProcessResourceProcessCapabilityChangeType{ CurrentCapabilityChanged,
AssignedCapabilityChanged, PossibleCapabilityChanged };
typedef struct ProcessResourceProcessCapabilityChangedFilter_Structure {
Property name; // “Name”,aProcessResource’s name
Property changeType; //“ChangeType”,
ProcessResourceProcessCapabilityChangeType
} ProcessResourceProcessCapabilityChangedFilters;
typedef struct ProcessResourceProcessCapabilityChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ProcessResourceProcessCapabilityChangedFilters eventFilterData;
Properties eventNews;
ProcessResource aProcessResource;
} ProcessResourceProcessCapabilityChangedEvent;
ProcessResourceHistory
/* Process ResourceHistory added event definition. */
#define ProcessingHistoryAddedSubject
“/ProcessHistory/ProcessResourceHistory/ProcessingHistoryAdded”
typedef struct ProcessingHistoryAddedFilter_Structure {
Property name; // “Name”,aProcessResource’s name
// Property; //“ProcessingHistoryAdded”,
} ProcessingHistoryAddedFilters;
typedef struct ProcessingHistoryAddedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ProcessingHistoryAddedFilters eventFilterData;
Properties eventNews;
// ProcessResourceHistory aProcessResourceHistory;
} ProcessResourceHistoryAddedEvent;
Material Location
/* Material Location send or receive of material. */
#define MaterialTrackingLocationMaterialChangedSubject
“/MachineManagement/MaterialTrackingLocation/MaterialChanged”
enum MaterialChangedState { MaterialUndefined, MaterialReceived, MaterialSent };
typedef struct MaterialTrackingLocationMaterialChangedFilters_Structure {
Property machineName; // “MachineName”, aMachine’s name
Property MaterialTrackingLocationName;
// “MaterialTrackingLocationName”,
// aMaterialTrackingLocation’s name
Property materialName; // “MaterialName”, aMaterial’s name
Property state; //“MaterialChangedState”,MaterialChangedState
} MaterialTrackingLocationMaterialChangedFilters;
typedef struct MaterialTrackingLocationMaterialChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
MaterialTrackingLocationMaterialChangedFilters eventFilterData;
Properties eventNews;
Machine aMachine;
MaterialTrackingLocation aMaterialTrackingLocation;
Material aMaterial;
} MaterialTrackingLocationMaterialChangedEvent;
Process Capability
/* Change in the machines capable of performing a specific process capability. */
#define ProcessCapabilityMachineChangedSubject
“/ProcessCapabilityManagement/ProcessCapability/MachineChanged”
typedef struct ProcessCapabilityMachineChangedFilters_Structure {
Property name; // “Name”, aProcessCapability’s name
} ProcessCapabilityMachineChangedFilters;
typedef struct ProcessCapabilityMachineChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ProcessCapabilityMachineChangedFilters eventFilterData;
Properties eventNews;
ProcessCapability aProcessCapability;
} ProcessCapabilityMachineChangedEvent;
Recipe Manager
/* Machine Recipe lifecycle event definition. */
#define MachineRecipeLifecycleSubject
“/RecipeManagement/RecipeManager/MachineRecipeLifecycle”
typedef struct MachineRecipeLifecycleFilters_Structure {
Property name; // “Name”, aMachineRecipe’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} MachineRecipeLifecycleFilters;
typedef struct MachineRecipeLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
MachineRecipeLifecycleFilters eventFilterData;
Properties eventNews;
// MachineRecipe aMachineRecipe;
// Except when “Delete” where value will be nil
} MachineRecipeLifecycleEvent;
MachineRecipe
/* Change in the parameters for a machine recipe. */
#define MachineRecipeParameterChangedSubject
“/RecipeManagement/MachineRecipe/ParameterChanged”
typedef struct MachineRecipeParameterChangedFilters_Structure {
Property name; // “Name”, aMachineRecipe’s name
} MachineRecipeParameterChangedFilters;
typedef struct MachineRecipeParameterChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
MachineRecipeParameterChangedFilters eventFilterData;
Properties eventNews;
// MachineRecipe aMachineRecipe;
} MachineRecipeParameterChangedEvent;
Order Manager
/* Order lifecycle event definition. */
#define OrderLifecycleSubject “/OrderManagement/OrderManager/OrderLifecycle”
typedef struct OrderLifecycleFilters_Structure {
Property name; // “Name”, aOrder’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} OrderLifecycleFilters;
typedef struct OrderLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
OrderLifecycleFilters eventFilterData;
Properties eventNews;
// Order anOrder;
// Except when “Delete” where value will be nil
} OrderLifecycleEvent;
Plan Manager
/* Product Request lifecycle event definition. */
#define ProductRequestLifecycleSubject
“/PlanManagement/PlanManager/ProductRequestLifecycle”
typedef struct ProductRequestLifecycleFilters_Structure {
Property name; // “Name”, aProductRequest’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} ProductRequestLifecycleFilters;
typedef struct ProductRequestLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ProductRequestLifecycleFilters eventFilterData;
Properties eventNews;
ProductRequest aProductRequest;
// Except when “Delete” where value will be nil
} ProductRequestLifecycleEvent;
Plan
/* Plan changed event definition. */
#define PlanChangedSubject “/PlanManagement/Plan/Changed”
typedef struct PlanChangedFilters_Structure {
Property name; // “Name”, aPlan’s name
} PlanChangedFilters;
typedef struct PlandChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
PlanChangedFilters eventFilterData;
Properties eventNews;
// Plan aPlan;
} PlanChangedEvent;
Product Request
/* Product request state changed event definition. */
#define ProductRequestStateChangedSubject “/Enterprise/ProductRequest/StateChanged”
enum ProductRequestState {ProductRequestUndefined, ProductRequestNotPlanned,
ProductRequestPlanned, ProductRequestNotInRelease, ProductRequestInRelease,
ProductRequestInWork, ProductRequestOnHold, ProductRequestCompleted };
typedef struct ProductRequestStateChangedFilters_Structure {
Property name; // “Name”, aProductRequest’s name
Property formerState; // “formerState”, ProductRequestState
Property newState; // “newState”, ProductRequestState
} ProductRequestStateChangedFilters;
typedef struct ProductRequestStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
ProductRequestStateChangedFilters eventFilterData;
Properties eventNews;
ProductRequest aProductRequest;
} ProductRequestStateChangedEvent;
Dispatching Manager
/* Dispatcher lifecycle event definition. */
#define DispatcherLifecycleSubject
“/ScheduleManagement/DispatchingManager/DispatcherLifecycle”
typedef struct DispatcherLifecycleFilters_Structure {
Property name; // “Name”, aDispatcher’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} DispatcherLifecycleFilters;
typedef struct DispatcherLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
DispatcherLifecycleFilters eventFilterData;
Properties eventNews;
Dispatcher aDispatcher;
// Except when “Delete” where value will be nil
} DispatcherLifecycleEvent;
Person Manager
/* Person lifecycle event definition. */
#define PersonLifecycleSubject “/PersonManagement/PersonManager/PersonLifecycle”
typedef struct PersonLifecycleFilters_Structure {
Property name; // “Name”, aPerson’s name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} PersonLifecycleFilters;
typedef struct PersonLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
PersonLifecycleFilters eventFilterData;
Properties eventNews;
Person aPerson;
// Except when “Delete” where value will be nil
} PersonLifecycleEvent;
Person
/* Person capacity changed event definition. */
#define PersonCapacityChangedSubject “/PersonManagement/Person/CapabilityChanged”
typedef struct PersonCapacityChangedFilters_Structure {
Property name; // “Name”, aPerson’s name
} PersonCapacityChangedFilters;
typedef struct PersonCapacityChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
PersonCapacityChangedFilters eventFilterData;
Properties eventNews;
Person aPerson;
} PersonCapacityChangedEvent;
Material Movement
#define TransportJobSupervisorConfigurationChangedsubject
“/MaterialMovementManagement/TransportJobSupervisor/ConfigurationChanged”
enum TransportJobSupervisorConfiguration { AreaEnabled, AreaDisabled, MachineEnabled,
MachineDisabled, MaterialPortEnabled, MaterialPortDisabled } ;
typedef struct TransportJobSupervisorConfigurationChangedFilter_Structure {
Property Name; //TransportJobSupervisor’s name
Property TransportJobSupervisorConfiguration;
Property destinationName;//Name of the particular entity that changed
} TransportJobSupervisorConfigurationChangedFilter;
typedef struct TransportJobSupervisorConfigurationChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
TransportJobSupervisorConfigurationChangedFilter eventFilterData;
Properties eventNews;
TransportJobSupervisor aTransportJobSupervisor;
} TransportJobSupervisorConfigurationChangedEvent;
Process Control
#define ControlExecutorStatusSignal “/ControlExecution/ControlExecutor/StatusChanged”
typedef struct ControlExecutorStatusNews_Structure {
Property theControlExecutor;
Property identifier;
Property strategy; // name = “RunningStrategy”, value =
aRunningStrategy
Property status; // name = “ExecutorStatus”, value = Status
} ControlExecutorStatusNews ;
/* The FaultEvent is emitted by the ControlExecutor in response to a fault being detected through
analysis. The information in the event includes the fab tool the fault occurred on, the lot and
wafer number, as well as data for one or more charts that will be used to illustrate the fault.*/
#defineAPCFaultSignal “/ControlExecution/ControlExecutor/APCFault”
typedef struct APCFaultEventFilters_Structure {
Property name; // “MachineName”, aMachine’s name
} APCFaultEventFilters;
LotJob
/* LotJob priority changed event definition. */
#define LotJobPriorityChangedSubject “/FactoryOperations/LotJob/LotJobPriorityChanged”
typedef struct LotJobPriorityChangedFilter_Structure {
Property name; // “Name”, LotJob’s name
Property priority; //“Priority”, the new priority
} LotJobPriorityChangedFilters;
typedef struct LotJobPriorityChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
LotJobPriorityChangedFilters eventFilterData;
Properties eventNews;
LotJob aLotJob;
} LotJobPriorityChangedEvent;
SupportResource
/* SupportResource state changed event definition. */
#define SupportResourceStateChangedSubject
“/MachineManagement/SupportResource/SupportResourceStateChanged”
typedef struct SupportResourceStateChangedFilters_Structure {
Property name; // “Name”, aResource’s name
Property formerState; // “FormerState”, State
Property newState; // “NewState”, State
} SupportResourceStateChangedFilters;
typedef struct SupportResourceStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
SupportResourceStateChangedFilters eventFilterData;
Properties eventNews;
SupportResource aSupportResource;
} SupportResourceStateChangedEvent;
Recipe Management
/* RecipeNamespace lifecycle event definition. */
#define RecipeNamespaceLifecycleSubject
“/RecipeManagement/RecipeNamespaceManager/RecipeNamespaceLifecycle”
typedef struct RecipeNamespaceLifecycleFilters_Structure {
Property name; // “Name”, aRecipeNamespace name
Property lifecycleEvent; // “LifecycleEvent”, LifecycleState
} RecipeNamespaceLifecycleFilters;
typedef struct RecipeNamespaceLifecycleEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
RecipeNamespaceLifecycleFilters eventFilterData;
Properties eventNews;
RecipeNamespace aRecipeNamespace;
// Except when “Delete” where value will be nil
} RecipeNamespaceLifecycleEvent;
RecipeNamespace
/* Change in the parameters for a machine recipe. */
#define RecipeParameterChangedSubject
“/RecipeManagement/RecipeNamespace/RecipeParameterChanged”
typedef struct RecipeParameterChangedFilters_Structure {
Property name; // “Name”, aRecipe’s name
} RecipeParameterChangedFilters;
typedef struct RecipeParameterChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
RecipeParameterChangedFilters eventFilterData;
Properties eventNews;
// MachineRecipe aMachineRecipe;
} RecipeParameterChangedEvent;
PMSpecification
/* Preventive maintenance schedule state changed event definition. */
#define PMSpecificationStateChangedSubject
“/PreventiveMainentance/PMSpecification/StateChanged”
enum PMSpecificationState { PMSpecificationUndefined, PMSpecificationQueued,
PMSpecificationActive, PMSpecificationCompleted, PMSpecificationCancelled };
typedef struct PMSpecificationStateChangedFilters_Structure {
Property name; // “Name”, aPMSpecification’s name
Property formerState; // “formerState”, PMSpecificationState
Property newState; // “newState”, PMSpecificationState
} PMSpecificationStateChangedFilters;
typedef struct PMSpecificationStateChangedEvent_Structure {
string eventSubject;
TimeStamp eventTimeStamp;
PMSpecificationStateChangedFilters eventFilterData;
Properties eventNews;
PMSpecification aPMSpecification;
} PMSpecificationStateChangedEvent;
The following is just a simple list of the events from the above section in one convenient place.
Events
/JobManagement/JobSupervisor/JobLifecycle
/JobManagement/Job/StateChanged
/Factory/MESFactory/StateChanged
/Factory/Area/AreaConfigurationChanged
/Resource/ComponentManager/StateChanged
/Factory/ComponentManager/ComponentManagerRegistrationChanged
/ProductManagement/ProductManager/ProcessGroupLifecycle
/ProductManagement/ProductManager/LotLifecycle
/ProductManagement/ProductManager/WaferLifecycle
/ProductManagement/Lot/StateChanged
/ProductManagement/Lot/QuantityChanged
/ProductManagement/Lot/PriorityChanged
/ProductManagement/Lot/DueDateChanged
/ProductManagement/Lot/FlowPositionAdjusted
/ProductManagement/Lot/ProcessFlowChanged
/ProductManagement/Lot/ReservationChanged
/DurableManagement/DurableManager/TransportGroupLifecycle
/DurableManagement/DurableManager/MaterialContainerLifecycle
/DurableManagement/DurableManager/ProcessDurableLifecycle
/DurableManagement/Durable/StateChanged
/DurableManagement/Durable/LocationChanged
/DurableManagement/Durable/ReservationChanged
/ConsumableManagement/ConsumableManager/ConsumableLifecycle
/ConsumableManagement/Consumable/ConsumableStateChanged
/ConsumableManagement/Consumable/ConsumableQuantityChanged
/DocumentManagement/DocumentManager/DocumentLifecycle
/DocumentManagement/DocumentManager/VersioningRequired
/DocumentManagement/DocumentSpecification/DocumentRevisionLifecycle
/DocumentManagement/DocumentRevision/StateChanged
/VersionManagement/VersionManager/ChangeNoticeLifecycle
/VersionManagement/ChangeNotice/StateChanged
/VersionManagement/ChangeNotice/Rejected
/VersionManagement/ChangeNotice/SignoffsChanged
/ProcessDefinitionManagement/ProcessDefinitionManager/ProcessDefinitionLifecycle
/ProcessDefinitionManagement/ProcessDefinitionManager/ProcessFlowLifecycle
/ProcessDefinitionManagement/ProcessDefinitionManager/ProcessFlowContextLifecycle
/ProductSpecificationManagement/ProductSpecificationManager/ProductSpecificationLifecy
cle
/BOMSpecificationManagement/BOMSpecificationManager/BOMSpecificationLifecycle
/MachineManagement/MachineManager/MachineLifecycle
/MachineManagement/Machine/PortAvailable
/MachineManagement/Machine/SetupChanged
/MachineManagement/Machine/ProcessRunSizeChanged
/MachineManagement/Machine/E10StateChanged
/MachineManagement/Machine/MachineResourceLifecycle
/MachineManagement/Machine/MachineReservationChanged
/MachineManagement/Machine/MachineProcessCapabilitiesChanged
/MachineManagement/StorageMachine/CapacityChanged
/MachineManagement/StorageMachine/MachinesChanged
/MachineManagement/TransportMachine/CapacityChanged
/MachineManagement/MachineResource/E10StateChanged
/MachineManagement/MachineResource/StateChanged
/MachineManagement/MachineResource/MaterialTrackingLocationLifecycle
/MachineManagement/MaterialTrackingLocation/MaterialChanged
/MachineManagement/MaterialTrackingLocation/StateChanged
/MachineManagement/ProcessResource/ProcessCapabilityChanged
/ProcessHistory/ProcessResourceHistory/ProcessingHistoryAdded
/ProcessCapabilityManagement/ProcessCapabilityManager/ProcessCapabilityLifecycle
/ProcessCapabilityManagement/ProcessCapability/MachineChanged
/PreventiveMaintenance/PMScheduleManager/PMScheduleLifecycle
/PreventiveMainentance/PMSchedule/StateChanged
/RecipeManagement/RecipeManager/MachineRecipeLifecycle
/RecipeManagement/MachineRecipe/ParameterChanged
/RecipeManagement/MachineRecipe/AssignmentChanged
/DataCollectionSpecificationManagement/DataCollectionSpecificationManager/DataCollecti
onSpecificationLifecycle
/OrderManagement/OrderManager/OrderLifecycle
/PlanManagement/PlanManager/ProductRequestLifecycle
/PlanManagement/Plan/Changed
/PlanManagement/ProductRequest/StateChanged
/ScheduleManagement/DispatchingManager/DispatcherLifecycle
/PersonManagement/PersonManager/PersonLifecycle
/PersonManagement/Person/AvailabilityChanged
/PersonManagement/Person/StateChanged
/PersonManagement/Person/ShiftChanged
/FactoryOperations/ScheduleInterpreterManager/ScheduleInterpreterLifecycle
/MaterialMovementManagement/TransportJobSupervisor/ConfigurationChanged
This section generalizes the rules found in the analysis of the current CIM Framework events.
These rules can be used by future domain focus teams that are evolving the CIM Framework to
decide when and how to define new events.
Rule #1: When to define a new event?
The most important aspect of this rule is to understand that events are not meant to provide flow
of control within the CIM Framework. In other words, an event should not be used to generate an
expected action upon another object. Events are informational in intent only. If an event has an
expected consumer and an expected action to result from this event, it should not be an event but
should instead be a direct method invocation.
The easiest way to answer whether an informational event should be generated is to ask the
question: “Would a monitoring application be interested in this information?” Examples of
monitoring applications can include scheduling or planning applications, manufacturing status
display applications, or an ad-hoc engineer developed monitoring query for a specific process or
product.
Rule #2: What informational events should be defined?
There is a certain subset of informational events that should always be defined. They are:
ì Life cycle events: creation, deletion, copy and move of any managed object
ì State changed events: any object that changes state must publish a single event to represent
the state change. This implies that the interface for that object must have an enumerated type
defined for all of its states. The states that are defined in the enumerated type must be the
lowest level states, not any of the super-states.
ì Important attribute changes: any object that has a significant change to its attributes should
publish an event for that. The domain experts will know what attributes are important enough
to be published when changed.
ì Business rule changes: any object that encompasses a business rule that may impact how
other objects work must publish an event when that business rule changes. An example of
this is with the version management on and off condition managed by the Document Manager
interface.
Rule #3: What filterable items should be defined with an event?
This rule is more flexible in nature but does have a certain minimum requirement. For each of the
standard events that are defined, the following filterable items should accompany them:
For all types: The name (or identifier) of the object publishing the event. The
actual object reference should be included as part of body of the
event (non-filterable data) and should be nil when it is a lifecycle
delete event.
Lifecycle: The enumerated value for the lifecycle event that occured
State changes: The enumerated value for the former state of the instance publishing
the event. The enumerated value for the new state of the instance
publishing the event.
Attribute changes: The new value of the attribute that changed
Business rule changes: The new value of the business rule that changed
APPENDIX E
SCENARIO EXAMPLES
These scenario diagrams offer interpretations of the Process Control section of the CIM
Framework. These diagrams can be viewed as paper validations of the interfaces in that section.
The first set of diagrams, in object interaction format, are from the APCFI Consortium and
illustrate their interpretation of the interfaces for a startup, three execution, and an abort scenario.
The second set is from Texas Instruments and, similarly, offers TI’s interpretation of the
specification to implement a control and fault detection scenario. These diagrams are not
interpreted as part of the specification, but, rather as illustrations that different implementations
are feasible using the same set of interfaces.
Plug-in
Factory
3. Factory
7: PluginHandle setupPlugin(Plugin)
lookupPluginFactory(
8: ControlValues executePlugin(
FactoryType)
5.PluginContents PluginHandle,
GetContentsByType( PerformanceData)
PluginContentsType) 9: unsetupPlugin(PluginHandle)
4: Plugin lookupPlugin(
PluginName)
Control Executor
Control
13: MachineEvent
Executor 10: downloadRecipeUpdates(
RunData)
11: setupMachine()
12: startMachine()
6. query
15: add_run_data(RunData)
2: ControlData 16: close()
Trader findData(
DataTagSequence)
14: run_record
create_run_record(
17: updateValues(
ExecutionContext)
NameValueSequence)
Control
DB
Manager
Control
Control Archive
Data Manager
Control Archive
1: ControlExecutorStatusEvent
{Status = "StrategyStarted"}
18: ControlExecutorStatusEvent Control Manager
{Status = "StrategyCompleted"}
Additional Notes:
5. Gets the type of plugin (optional; only used if there
are different types of plugins, each executed by a
different Plugin Executor)
6. Gets the Plugin Executor for this type of Plugin from
the Trader
This scenario covers the initiation of control activity by some other component of the CIM
Framework. In response to the executeControl call on the Control Executor Manager, the Control
Strategy to be executed is selected by the Control Manager. The Control Executor Manager
makes two GetContentsByType calls on the returned RunningControlStrategy. The first call is
used to get the capabilities required by the Control Strategy to be executed (for example,
ContentType = RequiredCapabilities). The returned capabilities are used to query servers to
fullfill those capabilities through the Trader. Finally, the second GetContentsByType call is used
to get the scripted action sequence that will be executed by the Control Executor (for example,
ContentType = “Script”).
Plug-In public
Plug-In
Manager Executor
PlugIn Machine
Plug-in
12: PluginHandle setupPlugin(Plugin)
Factory
13: ControlValues
executePlugin(PluginHandle,
Plug-In Manager PerformanceData)
14: unsetupPlugin(PluginHandle)
8. Factory
10: PluginContents lookupFactory(FactoryType)
GetContentsByType(
9: Plugin lookupPlugin(
PluginContentsType)
PluginName)
Control Executor
Control 6: DataAvailableEvent
Strategy
2: setupDataCollection(
Executor
DataCollectionPlanSequence)
11. query 3: enableDataCollection()
4: setupMachine()
5: startMachine()
Control 16: add_run_data(run_data)
Data 17: updateValues( 18: close()
NameValueSequence)
15: run_record
7: ControlData create_run_record(execution_context)
findControlData(
DataTagSequence)
Control
Database
Manager Control
Archive
Control Manager
Data Control
private to APC Archive
Run Record
public
Control Database
Control Archive
Note: For execute_control invocations with an
execution_type of "script", the script will dictate the
interactions and sequence of interactions. This
particular OID is intended to represent update model
parameters based on metrology data.
1: ControlExecutorStatusEvent
{Status = "StrategyStarted"}
19: ControlExecutorStatusEvent
{Status = "StrategyCompleted"}
Control Manager
Control Manager
Control
Strategy
Executor 3: setupDataCollection(
14. query DataCollectionPlanSequence)
6: enableDataCollection()
7: setupMachine()
8: startMachine()
Trader
21: update_display(
display_data)
11: add_run_data(run_data)
2: run_record create_run_record 19: add_run_data(run_data)
(execution_context) 22: close()
Operator GUI
20: ControlData
addContolData
Operator GUI (DataTagSequence,
NameValueSequence)
Control
Control Archive
Database Manager
Manager
Control
Archive
Control
Run Record
Data
public
private to APC
Control Archive
Control Database
1: ControlExecutorStatusEvent
{Status = "StrategyStarted"}
23: ControlExecutorStatusEvent
{Status = "StrategyCompleted"}
Control
Strategy Control
Manager
Running
Control
Strategy
1.2 ControlStrategy
1.3: Contents getControlStrategy()
GetContentsByType(
ContentsType)
1.5: Contents 1.1: RunningControlStrategy selectStrategy(
GetContentsByType( ExecutionContext)
ContentsType)
Control Executor
Control
Control
Executor
Executor
Manager
1:ControllerReturns
execute_control (
ExecutionType,
ExecutionContext,
ControllerArguments);
1.4: query
Inside APC
Outside APC
Other
Trader CIM Framework
Component
Trader Service
Abort OID
12.1: PluginContents
GetContentsByType(PluginContentsType) Plug-In Executor
private to APC
Machine Control
Plug-In Plug-In
Manager Executor public
PlugIn
Machine
Plug-in 12: PluginHandle setupPlugin(Plugin)
Factory 13: ControlValues
executePlugin(PluginHandle,
PerformanceData)
Plug-In Manager 14: unsetupPlugin(PluginHandle)
8. PluginFactory
10: PluginContents lookupPluginFactory()
GetContentsByType(
PluginContentsType) 9: Plugin lookupPlugin(
PluginName)
Control Executor
Trader
11. query
Control 6: DataAvailableEvent
Strategy
Executor 2: setupDataCollection(
DataCollectionPlanSequence)
Control
17. RunningStrategy 3: enableDataCollection()
Executor
getRunningStrategy() 4: setupMachine()
Manager
20. makeAborting() 5: startMachine()
16: ControlExecutorSeq
getExecutors()
Control
18. RunningControlStrategyID Control
Database
getID() Archive
Manager
19. ExecutionContext Manager
getRunningContext()
Control Control
Data Archive
private to APC Run Record
public
Control Database
Control Archive
Running
Control
Strategy
Control Manager
Note: The abort message can appear at any point in the
sequence of actions. An alternate sequence is
performed to abort the run. In this example, a note is
put in the run record and the run record closed.
Control Manager
executePlugin()
running
unsetupPlugin()
calculatedSettings()
selectRecipe()
machineSettings()
downloadRecipe()
Activity Control Control Control Running Control Plugin Plugin Plugin Plugin Recipe Machi
Manager Executor Executor Manager Control Strategy Manager Factory Executor Manager
Manager Strategy
This scenario describes a message sequence for performing a calculate settings transaction via a plugin application u
Framework specification. Some of the details relating to argument types, return values and database interface have be
clarity. Some objects and messages/events in the above scenario are application specific (i.e. not part of the APC Fram
These types of components are expected in any implementaiton of the Framework, and may be encompassed in other
Framework spec. The non-APC Framework objects, messages and events are indicated by ital
setupDataCollection()
startDataCollection()
data
runDataAvailable()
lookupPlugin()
setupPlugin()
executePlugin()
running
unsetupPlugin()
analysisResults()
shutDownMachine()
shutdown
Activity Control Control Control Running Control Plugin Plugin Plugin PluginEquipment Machi
Manager Executor Executor Manager Control Strategy Manager Factory Executor Manager
Manager Strategy
This scenario describes a message sequence for performing fault detection via a plugin application using the APC Framewor
the details relating to argument types, return values and database interface have bee removed for clarity. Some objects and m
above scenario are application specific (i.e. not part of the APC Framework Spec). This particular scenario uses a plugin to a
run. The analysis identifies a fault and returns the analysis reults to the Control Executor. The COntrol Executor then initiates
the machine by way of an equipment manager. These types of components are expected in any implementaiton of the Frame
encompassed in other parts of the CIM Framework spec. The non-APC Framework objects, messages and events are indicate
2: Return Job
3: InformJobStarted (Job)
4: informJobCompleted (Job)
2: Return Job
3: informJobStarted (Job)
4: informJobCompleted (Job)
allAssignedToMachinesPersons .....................................328
allAvailableForWorkPersons ..........................................328
A allBOMBodies ................................................................215
allBOMSpecifications.....................................................213
abnormalEnter ................................................ 201, 207, 210 allBOMSpecifications_forProduct ..................................213
abnormalExit .................................................. 201, 207, 211 allCalendarDays..............................................................111
abortAllJobs ..................................................................... 68 allCanceledJobs ................................................................69
abortRunningControlStrategy......................................... 299 allCassettes......................................................................177
activeCassettes................................................................ 177 allChangeNotices ..............................................................86
activeRevision .................................................................. 80 allCompletedJobs..............................................................69
actualCompletionTime ........................................... 163, 171 allComponentManagers ..................................................103
addArea .......................................................................... 103 allConsumables...............................................................191
addAssignedCapability........................................... 259, 262 allContainedMachineResource .......................................252
addChannelForEvent ........................................................ 92 allCurrentCapabilities .....................................................258
addControlData .............................................................. 312 allCurrentProcessMachineCapabilities ...........................258
addDays.......................................................................... 111 allCurrentProcessResourceCapabilities ..........................258
addDie_atCoordinate...................................................... 159 allDescendantLots...........................................................162
addDispatchableObject................................................... 320 allDie ..............................................................................159
addDispatchDecision...................................................... 322 allDispatchableObjects ...................................................321
addDurationUsed............................................................ 179 allDispatchers..................................................................319
addHistory ........................................................................ 96 allEnabledAreas ..............................................................240
addHistoryEvent............................................................... 97 allEnabledMachines........................................................240
addLot ............................................................................ 173 allEnabledMaterialPorts..................................................241
addMachine ............................................................ 109, 116 allEventChannelsFor.........................................................93
addMachineRecipe ......................................................... 279 allExecutingJobs ...............................................................69
addMaterial............................................................. 140, 182 allFinishedJobs .................................................................69
addMaterialAtPosition.................................................... 184 allHistories........................................................................96
addMaterialContainer ..................................................... 188 allInventoryRegionNames...............................................200
addMaterialGroup .......................................................... 140 allInventoryRegions................................................198, 200
addMaterials ................................................................... 140 allInventoryRegionSystemNames...................................197
addNameToDefaultSignOffSet......................................... 87 allInventoryRegionSystems ............................................197
addNonCycleTime.......................................................... 202 allJobs ...............................................................................69
addPerson ....................................................................... 110 allJobSupervisors ..............................................................73
addPlannedShutDown .................................................... 111 allLotFamilies .................................................................145
addPlannedStartUp ......................................................... 111 allLots .....................................................................145, 186
addPossibleCapability ............................................ 259, 262 allLotsActive...................................................................146
addProcessMachine ........................................................ 278 allLotsCompleted............................................................146
addProcessResource ....................................................... 236 allLotsCreated.................................................................146
addProcessRun ............................................................... 149 allLotsEmptied................................................................146
addProductType ............................................................. 145 allLotsFinished ...............................................................146
addQualification ............................................................. 332 allLotsInProduction ........................................................146
addResponsibility_toCategory........................................ 332 allLotsInRework .............................................................146
addRevision...................................................................... 79 allLotsNotOnHold ..........................................................146
addSensor ....................................................................... 252 allLotsOnHold ................................................................146
addSkill .......................................................................... 332 allLotsReleased...............................................................146
addSubArea .................................................................... 109 allLotsScrapped ..............................................................146
addSupportResource............................................... 285, 287 allLotsShipped ................................................................146
addWafer_atPosition ...................................................... 186 allMachines.............................................................103, 116
age .................................................................. 121, 162, 205 allMaterial...............................................................244, 246
allAbortedJobs.................................................................. 69 allMaterialContainers......................................................189
allAbortingJobs ................................................................ 69 allMaterialGroups ...........................................................141
allActiveJobs .................................................................... 69 allMaterialHeld ...............................................................269
allAreaPMActivitesDueNow.......................................... 285 allMaterialInStorage ...............................................244, 246
allAreaPMActivitesDuringDuration............................... 284 allMaterialInTransit ................................................244, 246
allAreas........................................................................... 103 allMaterialMovementControllers....................................246
allAssignedCapabilities .................................................. 258 allMaterials .....................................................................141
allAssignedDurables....................................................... 255 allNotAllocatedPorts.......................................................256
allAssignedProcessMachineCapabilities ........................ 258 allNotAvailableForWorkPersons ....................................328
allAssignedProcessResourceCapabilities ....................... 258 allNotPausedJobs ..............................................................69
allAssignedToJobsPersons ............................................. 328 allOnShiftPersons ...........................................................327
allPausedJobs ....................................................................69
E10State ........................................................................... 41
effectivity........................................................................ 346 G
emptyPositions ............................................................... 184
enableArea...................................................................... 240 getActivationDate .............................................................81
enableDataCollection ..................................................... 314 getAllContents ................................................................295
enableMachine ............................................................... 240 getAllMaterialTrackingLocations ...................................255
enableMaterialPort ......................................................... 241 getAllRecipeNamespaces................................................276
enter........................................................................ 202, 211 getAlternativeProcessOperationSpecifications ...............226
Enterprise Abstract Interface .......................................... 123 getAreaIdentifier .............................................................109
EnterpriseExecutor ......................................................... 124 getAvailableCapacity......................................................270
entries ............................................................................. 203 getBin..............................................................................158
Event Broker .................................................................... 91 getCapacity .....................................................................182
EventBroker ..................................................................... 92 getChildPartsUnit ...........................................................216
executePlugin ................................................................. 297 getChildProductSpecification .........................................216
executeRecipe................................................................. 282 getCollectedData.............................................................314
exit.......................................................................... 202, 211 getCommissionedTimeStamp .........................................179
exits ................................................................................ 203 getConsummablesForProcessResource...........................233
getConsummablesForProcessResources .........................228
getContainingMachine ....................................................252
F getContainingMachineResource .....................................252
getContentByType ..........................................................295
Factory Component ........................................................ 101 getContents .............................................................182, 302
Factory Operations Component...................................... 117 getContentsByType.........................................................302
Factory Operations Scenario .............................................. 9 getContextSpec ...............................................................302
FactoryCalendar ............................................................. 111 getControllerArguments..................................................306
FactorySupervisor .......................................................... 119 getControlResults............................................................306
findActiveJobNamed........................................................ 68 getControlStrategy ..........................................................303
findAnAvailableCassette ................................................ 177 getControlStrategyDescription........................................302
findBOMSpecificationNamed ........................................ 213 getControlStrategyFactory ..............................................299
findByIdentifier .............................................................. 327 getCurrentCapability.......................................................262
findCassetteNamed......................................................... 177 getCurrentProcessOperation ...........................................149
findChangeNoticeNamed ................................................. 86 getCurrentProcessOperations..........................................120
findCompletedJobNamed ................................................. 68 getDataCollectionPlanFactory ........................................310
findConsumableNamed .................................................. 191 getDeadline .......................................................................70
findControlData.............................................................. 312 getDefaultInventoryRegionSequence..............................199
findDispatcherFor........................................................... 319 getDefaultRecipeNamespace...........................................281
findDocumentNamed........................................................ 78 getDefaultValue ..............................................................114
findHistory ....................................................................... 96 getDepartment.................................................................331
findHistoryEvent .............................................................. 97 getDescription.........................................201, 251, 295, 346
findInventoryRegionNamed ........................................... 200 getDesignator ..................................................................346
findJobNamed .................................................................. 68 getDestinationArea .........................................................242
findLotNamed ................................................................ 145 getDestinationMachine ...................................................242
findMachineNamed ........................................................ 116 getDestinationPorts .........................................................242
findMachineResourceNamed ......................................... 252 getDispatchDecisions......................................................322
findNumberOfUnitsUntilPM.......................................... 285 getDispatchers.................................................................119
findPMSpecificationNamed ........................................... 286 getDocumentContents.......................................................81
findProcessCapabilityNamed ......................................... 235 getDocumentRevision.............................................215, 288
findProductNamed.......................................................... 146 getDurablesForProcessResource.....................................232
findProductSpecificationNamed..................................... 218 getDurablesForProcessResources ...................................228
findQualificationByIdentifier ......................................... 333 getDurationLimit.............................................................178
findQueuedJobNamed ...................................................... 68 getE10StateCode.............................................................252
findRevisionNamed.......................................................... 80 getEnterQuantity.............................................................208
findSensorNamed ........................................................... 252 getEnterTime...................................................................204
isWaitingToLogin........................................................... 163
M
Machine ..................................................................254, 257
J Machine Management Group..........................................248
MachineE10StateChangedEvent.....................................371
Job .................................... 70, 120, 131, 242, 261, 289, 306 MachineLifecycleEvent ..................................................370
Job Supervisor Abstract Interface Group.......................... 65 MachineListChangedEvent.............................................116
JobDeadlineCannotBeMetEvent ...................................... 70 MachineProcessCapabilitiesChangedEvent ....................372
JobDeadlineChangedEvent............................................... 70 MachineRecipe ...............................................................275
JobLifecycleEvent .......................................................... 357 MachineRecipeAssignmentChangedEvent .....................378
JobRequestor ............................................ 73, 122, 124, 132 MachineRecipeLifecycleEvent .......................................377
JobStateChangedEvent ............................................. 70, 357 MachineRecipeParameterChangedEvent ........................377
JobSupervisor ................... 67, 119, 130, 239, 257, 284, 305 MachineRegister .............................................................116
joinAll_into .................................................................... 145 MachineReservationChangedEvent ........................254, 372
joinCandidates ................................................................ 162 MachineResource....................................................251, 254
MachineResourceE10StateChangedEvent ..............251, 373
MachineResourceLifecycleEvent....................................371
L MachineResourceStateChangedEvent ............................373
machines .........................................................................110
lastEnterEventForLot ..................................................... 209 MachineSetupChangedEvent ..................................254, 371
lastExitEventForLot ....................................................... 209 makeAborted.....................................................................71
lastExitEventForMaterial ............................................... 204 makeActivated ..................................................................87
lastLotEnter .................................................................... 209 makeActive .......................................................................81
lastLotExit ...................................................................... 209 makeAllocated ................................................................149
lastMaterialEntered ........................................................ 204 makeAtWorkStation........................................................333
lastMaterialExited .......................................................... 204 makeAvailable ........................................................179, 192
LifecycleState................................................................... 41 makeCanceled...................................................................71
loadLotIntoMaterialContainer ........................................ 162 makeCompleted ......................................................126, 161
location........................................................................... 255 makeCreated ...................................................................161
LongSequence .................................................................. 41 makeEmptied ..................................................................161
lookupControlStrategy ................................................... 300 makeFinished ..........................................................149, 161
lookupDataCollectionPlan.............................................. 309 makeGoingToStandby.....................................................104
lookupPlugin .................................................................. 293 makeIdle..........................................................................149
lookupRunningControlStrategyByExecutionContext..... 301 makeInactive.....................................................................81
lookupRunningControlStrategyByID ............................. 301 makeInProduction ...........................................................149
lookupRunningControlStrategyByName........................ 301 makeInUse ......................................................................179
Lot .................................................................................. 160 makeInWork .....................................................................87
LotDueDateChangedEvent............................................. 361 makeLoggedIn ................................................................161
LotDueDateChangedFilters ............................................ 361 makeLoggedOut..............................................................161
lotEnter........................................................................... 207 makeNotAllocated ..........................................................149
lotExit............................................................................. 207 makeNotAtWorkStation..................................................333
LotFamily ....................................................................... 171 makeNotAvailable ..................................................179, 192
LotFlowPositionAdjustedEvent ..................................... 362 makeNotCompleted ........................................................126
LotJob............................................................................. 120 makeNotOnHold.............................................126, 149, 161
LotJobExecutor .............................................................. 122 makeNotPaused ................................................................71
LotJobPriorityChangedEvent ................................. 120, 383 makeNotRegistered...........................................................61
LotJobProductSpecificationChangedEvent .................... 120 makeOff ..........................................................................104
LotJobProductSpecificationyChangedEvent .................. 383 makeOffShift...................................................................333
LotLifecycleEvent .................................................. 144, 360 makeOnHold...................................................126, 149, 161
lotMovedFromOperation ................................................ 208 makeOnShift ...................................................................333
LotPriorityChangedEvent............................................... 361 makeOperating................................................................104
LotProcessFlowChangedEvent............................... 161, 362 makePaused ......................................................................71
LotQuantityChangedEvent ..................................... 160, 361 makePreparingToActivate.................................................87
LotQuantityChangedFilters ............................................ 361 makeProcessing...............................................................149
LotRegion....................................................................... 206 makeProcessingCompleted .............................................149
LotReservationChangedEvent ................................ 160, 363 makeRegistered.................................................................61
lots .................................................................................. 173 makeReleased .................................................................161
LotStateChangedEvent ........................................... 160, 360 makeScrapped.................................................149, 161, 179
makeShipped...........................................................149, 161
makeShuttingDown...................................................61, 104
T W
throughput .............................................................. 145, 202 Wafer ..............................................................................157
Time Services ................................................................... 90 WaferLifecycleEvent ..............................................144, 360
timeContribution ............................................................ 204 whatNextForMachine .....................................................320
TimePeriodInvalidSignal.................................................. 50 whatNextForPerson ........................................................320
timeRemaining ................................................................. 71 whereNextForLot............................................................320
timeSinceLastPM ........................................................... 285 wipCount ........................................................................145
TimeStamp ....................................................................... 41 workDay_for...................................................................112
TimeStampSequence ........................................................ 41
timeStartedInFactory ...................................................... 171
timesUsed ....................................................................... 179 Y
TimeT............................................................................... 41
TimeWindow.................................................................... 42 yield ................................................................................207
transferProducts_toLot ................................................... 162 ytdAverageAge ...............................................................204
transferWafers_toCassette .............................................. 186 ytdAverageCycleTime.....................................................204
TransportGroup .............................................................. 188 ytdAverageNonCycleTime..............................................204
TransportGroupLifecycleEvent .............................. 176, 363 ytdAverageYield.............................................................207
transportGroups .............................................................. 183 ytdLotsExistingQuantity .................................................207
TransportJob................................................................... 242 ytdPassedQuantity...........................................................207
TransportJobSupervisor.................................. 239, 244, 246 ytdScrappedQuantity.......................................................207
TransportJobSupervisorConfigurationChangedEvent ... 239,
381
transportTime ................................................................. 243
U
Unit................................................................................... 40
Units ................................................................................. 40
unitsProcessedSinceLastPM........................................... 285
unloadAll........................................................................ 185
unloadLotFromMaterialContainers ................................ 162
unloadMaterialAll .......................................................... 182
unregisterMaterialMovementController ......................... 246
unReserve ............................................................... 250, 268
unsetupDataCollection ................................................... 314
unsetupPlugin ................................................................. 297
updateRecipe .................................................................. 279
updateValues .................................................................. 313
uploadRecipe .................................................................. 282
uploadRecipeFromMachine ........................................... 279
V
verifyRecipe ................................................................... 282
Version Management Component .................................... 85
VersioningRequiredEvent ................................................ 77
versionManagementOff.................................................... 77
versionManagementOn..................................................... 77
VersionManagementRequiredEvent............................... 366
VersionManager ............................................................... 86
http://www.sematech.org