(Note: Terms in *italics* refer to other special terms. Items in ``code font`` are code fragments or specific code names.): activeQ A *Resource* object automatically creates and maintains its own activeQ, the queue (list) of process objects that are currently using one of the Resource's units. See `Resources`_. (See also the Glossary entry for *waitQ*.) activate Commands a *process object* to being executing its *PEM*. See `Starting and stopping SimPy process objects`_. Backus-Naur Form (BNF) notation This manual occasionally uses a modified Backus-Naur Form notation to exhibit command syntax, as in the description of the *activate* command:: activate(p, p.PEM([args]) [,{at=t|delay=period}] [,prior=False]) In this notation, square brackets [ ] indicate items that are optional, braces { } indicate items of which zero or more may be present, and a vertical bar | indicates a choice between alternatives (with none of them being a possibility). cancel Deletes all of a *process object's* scheduled future events. See `Starting and stopping SimPy process objects`_. entity An alternative name for *process object*. event A SimEvent object. See `Advanced synchronization/scheduling capabilities`_. FIFO An attribute of a resource object (i.e., a `Resource`_, `Level`_, or `Store`_) indicating that an associated queue (e.g., the *ActiveQ*, *waitQ*, *getQ*, or *putQ*) is to be kept in FIFO order. (See also the Glossary entries for *PriorityQ* and *qType*.) getQ The queue of processes waiting to take something from a `Level`_ or `Store`_ resource. See also the Glossary entry for *putQ*. interrupt Requests a "victim" *process object* to interrupt (i.e., to immediately and prematurely end) its current ``yield hold,...`` command. (Note: A process object cannot interrupt itself.) See `Asynchronous interruptions`_. Level A particular type of *resource facility* that models the production and consumption of a homogeneous undifferentiated "material." *Process objects* can increase or decrease the amount of material in a Level resource facility. See `Levels`_. Monitor A data recorder that compiles basic statistics as a function of time on variables such as waiting times and queue lengths. (Note: Monitors can also preserve complete time-series data for post-simulation analyses.) See `Recording Simulation Results`_. monitorType The type of Recorder_ to be used for recording simulation results. Usually this is either a Monitor_ or a Tally_. (See also the Glossary entry for *Recorder*.) monitored A (boolean) attribute of a *resource* object indicating whether to keep a record of its activity. See Recorder_. passivate Halts ("freezes") a *process object's* PEM. The process object becomes "passive". See `Starting and stopping SimPy Process Objects`_. PEM An abbreviation for *Process Execution Method*, q.v. preempt To force a *process* object currently using a *resource* unit to release it and make it available for use by another process object. See `Preemptive requests for a Resource unit`_. preemptable A settable attribute of *Resource* objects. The Resource object's units are preemptable if ``preemptable==True``, otherwise not. See `Preemptive requests for a Resource unit`_. priority A non-negative integer or real value controlling the order of *process* objects in a queue. Higher values represent higher priority. Higher priority process objects are placed ahead of lower priority ones in the queue. See also the Glossary entry for *FIFO*. PriorityQ An attribute of a resource object (i.e., a `Resource`_, `Level`_, or `Store`_) indicating that an associated queue (e.g., the *ActiveQ*, *waitQ*, *getQ*, or *putQ*) is to be kept in order of *priority*. (See also the Glossary entries for *FIFO*, *qType*.) process We usually call both process objects and their classes "processes" (with a small "p"). Thus, "process" may refer to a *Process class* or to a *process object*, depending on context. To avoid ambiguity or for added emphasis we often explicitly state whether a class or an object is intended. Process class A class that inherits from SimPy's ``Process`` class and contains at least one *Process Execution Method*. Process classes may also contain other methods -- in particular they may contain an ``__init__`` method. See `Processes`_. Process Execution Method A *Process class* method that contains at least one ``yield ...`` statement. See `Defining a process`_. process object An object created from (i.e., an instance of) a *Process class*. See `Processes`_. putQ The queue of processes waiting to add something to a `Level`_ or `Store`_ resource. See also the Glossary entry for *getQ*. reactivate Reactivates ("unfreezes") a passivated or a terminated *process object's* PEM. The *process object* becomes "active". See `Starting and stopping SimPy Process Objects`_. Recorder A device for recording simulation results. Unless otherwise specified, it usually refers either to a `Monitor`_ or a `Tally`_. However, Recorders also include histograms and observers. See `Recording Simulation Results`_ for *Monitors*, *Tallys*, and the other devices for recording simulation results. renege To leave a queue before acquiring a resource unit. See `Reneging -- leaving a queue before acquiring a resource`_. resource Same as "resource facility." A congestion point at which *process objects* may need to queue for access to resources. The term "resource" (with a small "r") is used as a generic term for the individual resource facilities provided by SimPy (i.e., Resources_, Levels_, and Stores_). qType An attribute of *resource* objects indicating whether an associated queue is to be kept in *FIFO* or *PriorityQ* order. See the Glossary entries for *waitQ*, *ActiveQ*, *putQ*,and *getQ*. See also the treatment of these queues in the sections on the individual resources (i.e., `Resources`_, `Levels`_, and `Stores`_). Resource A particular type of *resource facility* that possesses several identical *resource units*. A *process object* may acquire one (and only one) of the Resource's resource units. See Resources_ . Resource unit One of the individual resources associated with a *Resource* type of *resource facility*. See Resources_. SimEvent The SimPy class for defining and creating SimEvent objects. Occasionally designates a SimEvent object when context makes that usage clear. See `Advanced synchronization/scheduling capabilities`_. Store A particular type of *resource facility* that models the production and consumption of individual items. *Process objects* can insert or remove items from the Store's list of available items. See Stores_. Tally A particular type of *Recorder* that compiles basic statistics as a function of time on variables such as waiting times and queue lengths. (Note: Tallys do not preserve complete time-series data for post-simulation analyses.) See `Recording Simulation Results`_. (See also the Glossary entry for *monitorType*.) unit (of a Resource) One of the individual resource capabilities provided by a *Resource*. See `Resources`_. waitQ A *Resource* object automatically creates and maintains its own *waitQ*, the queue (list) of process objects that have requested but not yet received one of the Resource's units. See `Resources`_. (See also the Glossary entry for *activeQ*.)