• Skip to primary navigation
  • Skip to main content
  • Skip to primary sidebar
  • Lee L. Lowery, Jr., PhD, P.E.
  • Research
  • People
  • Contact

Lee L. Lowery, Jr.

Just another CoE WordPress site

Texas A&M University College of Engineering

Boss help file

Posted on July 28, 2021 by Abigail Stason

Capitalized words have help lists 12/30/1987

 General categories for the help system:

 PROGRAM    : general program structure

 DEFINITION : definition segment of program

 CONTROL    : program control

 LOGIC      : language block constructs for model building

 SYSTEM     : system functions, constants and variables

 OPERATORS  : system operators

 VARIATES   : distributed random number generators

%DEFINITIONS  segment

  Naming Conventions for all types:

    Simple : Name

    Indexed: Name.Number

  Simulation structures:

    RESOURCE   QUEUE        GATE           CHAIN

    HISTOGRAM  STATISTICS   VARSTATISTICS  DISTRIBUTION (or MAPPING)

    ENTITY     ATTRIBUTES   LABELS

  User variable types (all must be initialized):

    REAL  ARRAY  SEQUENCE  INTERVAL  STRING  TEXTFILE

  Define user functions:

    FUNCTION

  Renaming capability:

    ALIAS

%LOGIC segment has the following blocks (statements):

            simulation block statements

ARRIVE     CREATE     SCHEDULE    DEPART    WAIT

SEIZE      PREEMPT    RELEASE

COPY       COMBINE    GATHER      BUNDLE    UNBUNDLE

LINK       UNLINK     SETGATE     TESTGATE

STARTSTAT  ENDSTAT

SEARCH     REMOVE

INTERRUPT  RESET

            programming statements

FOR        WHILE      REPEAT

IF         DOCASES    GOTO        GOSUB     RETURN

PRINT      PRINTLN    EJECTPAGE   CLEARSCREEN

HALT       ABORT

%SYSTEM

  Constants: PI (=3.14159265), PosInf (= 10 to power 30),

             NegInf (= – PosInf), IntPosInf (=32000)

  Functions:

           sin(x)  cos(x)    tan(x)  arctan(x)        (angles in radians)

           exp(x)  log10(x)  ln(x)   sqrt(x)  sqr(x)  abs(x)

           floor(x)   (largest integer <= argument)

           ceiling(x) (smallest integer >= argument)

           sign(x)    (=1.0 if positive, 0.0 if negative)

           CAPACITY        USED            AVAILABLE    RCURNUMBER

           CUMNUMBER       CUMVALUE        CUMZEROS     MAXNUMBER

           CUMPRODUCTNT    CUMPRODUCTVT    LASTTIME

           BLOCKTOTAL      BLOCKCOUNT

  Variables:

           CLOCKTIME       EVENTCHAIN

  Internal Entity Attributes:

           ENTITYNUMBER  RESUMETIME  PREEMPTLEVEL  STATEMENT

           WATCHCHAR

%OPERATORS

    Arithmetic             : +  –  *  /  ^ (exponentiation)

                             max  min (e.g. x max y)

                             mod (x mod y is remainder of x/y)

    Relational operators   : =  <>  <  <=  >  >=

    Logical operators      : or  not  and  xor

    containment operators  : in  notin

    Conditional expressions: USE

    Iterative constructs   : SUM  PRODUCT  MAX  MIN  ARGMAX  ARGMIN

%USE        : Conditional expression

           : USE Val1 IF Cond ELSE USE Val2

             Use may be chained as in the example

  example  : f(x) =  Use 1 if x in [-5,0] else

           :         Use 2 if x in [1,3] else

           :         Use 3;

%SUM

           : SUM{ expr(var.) : var. IN Domain WITH expr. }

           : var. must be a defined variable

  example  : SUM{ Qused[name.i] : i IN <1, 2, 3> WITH i >= 2 }

%PRODUCT

           : PRODUCT { expr(var.) : var. IN Domain WITH expr. }

           : var. must be a defined variable

  example  : PRODUCT { Qused[name.i] : i in <1, 2, 3> with i >= 2 }

%MAX  MIN   : either binary operator (x MAX y) or the iterative operator

           : Operator { expr(var.) : var. IN Domain WITH expr. }

           : var. must be a defined variable

  example  : MIN { Qused[name.i] : i IN <1, 2, 3> WITH i >= 2 }

%ARGMIN ARGMAX : returns the first variable value satisfying min or max

           : Operator { expr(var.) : var. IN Domain WITH expr. }

           : var. must be a defined variable

  example  : ArgMin { Qused[name.i] : i IN <1, 2, 3> WITH i >= 2 }

%VARIATES   : system random variate generators

            RANDOM    CUNIFORM    NORMAL     LOGNORMAL   TRIANGULAR

            EXPD      ERLANG      GAMMA      BETA        WEIBULL

            POISSON   BINOMIAL    DUNIFORM

%PROGRAM       : three segments statements are required in order

 DEFINITION   : contains variables, functions, resources, etc.

  Begin       : optional syntax statement

   statements : definition segment statements

  End;        : optional syntax statement

 CONTROL      : simulation run time and print controls

   directives : run control directives

   EXITLOGIC  : (optional) logic segment for sophisticated program

              : control (see EXITLOGIC)

 LOGIC        : all program blocks representing the model

  Begin       : optional syntax statement

   statements : logic segment statements

END.          : model always terminates with END.

%CONTROL    : see individual help items for the following

   WATCH       view and animation list

   DIRECTIVES  for allowable run control directive

   EXITLOGIC   logic segment for sophisticated program control

%DIRECTIVES for control segment

StopTime   : simulation run length in clock units

StopCount  : run length in departure counts

ResetTime  : time at which statistics are cleared

ResetCount : departure count at which system statistics are cleared

PrintTime  : system statistics print increment in time units

PrintCount : system statistics print increment in departures

Randomize  : randomizes the starting random number seed(ON,OFF)

Seed       : starting random number seed integer in [1,32767]

BlockListing: statement/block summary information (ON, OFF) default is ON

              (cannot be used from within EXITLOGIC)

StatListing: statistics summary information (ON, OFF), default is ON

VarListing: Global variable summary information (ON, OFF), default is ON

Listing    : Enable/disable model listing (ON, OFF), default is ON

             Can be placed anywhere and used multiple times.

%WATCH      : for control segment

           : None of these directives can be used in EXITLOGIC

WatchList  : list of resource, queue and gate names

           : optional display symbol can be specified

           : example WatchList = { myRes:’M’, myQue:254};

           : individual entity WATCHCODE character over rides WATCHLIST

           : the future events chain name for WatchList is EventChain

WatchStatus: Determines the operating state of the animation system

           : (ON, OFF, SINGLESTEP) default is ON with a WatchList

           : OFF otherwise.  SINGLESTEP mode lets user control  simul.

WatchDelay : Approximate delay (micro seconds) between animation displays

           : default = 300.

%EXITLOGIC

   Provides a special logic segment for multiple runs and special

      processing the results of a run

   This logic is activated after the conclusion of each run

   The structure is the same as LOGIC with the following exceptions:

  begin (optional)

     programming statements

     no simulation statements except: SETGATE and RESET

     CLEAR, CONTINUE

 end; (required)

 To initiate a next run one of CLEAR, RESET or CONTINUE must be provided

   otherwise the system will terminate

%CLEAR  : clear simulation for next run

       : Available only in EXITLOGIC

       : clears all statistical quantities and removes all entities

       : Control directives and user variables retain values from the

       :   close of the previous run – user’s reponsibility to establish

       :   appropriate values

%CONTINUE  : resume simulation

       : Available only in EXITLOGIC

       : next simulation run simply continues the previous run

       : Control directives and user variables retain values from the

       :   close of the previous run – user’s reponsibility to establish

       :   appropriate values

%CLEARSCREEN : clears the screen (does not affect printer or file)

%EJECTPAGE  : program control for inserting a page break

           : if output option is print or file – ejects to new page

           : if the screen output is selected, then a clear screen occurs

%GOSUB      : branch to routine at specified label, return is

           : automatically setup by RETURN statement

example    : GOSUB myLabel;

%RETURN     : return from a GOSUB call, returns to statement following

           : the call statement unless an alternative branch is used

           : more than one return exit can be used in GOSUB routine

example    : IF ok THEN RETURN ELSE RETURN { Destination = errLabel };

%RESOURCE   : resource definition

Capacity   : capacity of resource; (1)

Queue      : optional named queue for resource wait list

example    : shop : RESOURCE = { Capacity = 1, Queue = myQ };

%QUEUE      : entity holding list with statistics computed

           : named queue connected to a resource

Capacity   : maximum number entities in list simultaneously;

Discipline : order entitles placed on list-(FIFO,LIFO, CHOICE)

           : CHOICE(KeyExpression); (FIFO)

Histogram  : flow time histogram name; optional

StatOnOff  : (ON,OFF) queue statistics print code; (On)

example    : ShopQ : QUEUE = { Discipline = CHOICE(PRIORITY)};

%CHAIN      : entity holding list with statistics computed

           : for user controlled linking and unlinking

Capacity   : maximum number entities in list simultaneously;

Discipline : order entitles placed on list-(FIFO,LIFO, CHOICE)

           : CHOICE(KeyExpression); (FIFO)

Histogram  : flow time histogram name; optional

StatOnOff  : (ON,OFF) chain statistics print code; (On)

example    : ShopC : CHAIN = { Discipline = CHOICE(PRIORITY)};

%GATE       : logic switch which queues entities if closed

Status     : initial status is OPEN or CLOSE; (OPEN)

Discipline : queueing discipline of waiting entities, FIFO

           : LIFO or CHOICE(Expression); (FIFO)

Histogram  : flow time histogram name; optional

StatOnOff  : (ON,OFF) gate queue statistics print code; (On)

example    : myGate : GATE = { Status = OPEN, Discipline = LIFO};

%STATISTICS : defines a flowtime statistics collection device

Histogram  : name of histogram for distribution; Optional

example    : sysflow : STATISTICS = { Histogram = hdata };

%VARSTATISTICS : defines a variable value statistics collection device

              : use as regular variable, but value statistics kept

Histogram     : name of histogram for distribution; Optional

Protect       : ON – statitics are not cleared by CLEAR or RESET

              : OFF – (default) is statistics are cleared

example       : x : VARSTATISTICS = { Histogram = hdata };

%HISTOGRAM  : data collection device definition

Cells      : number of cells or categories; Required

MinValue   : lower limit of histogram data; Required

MaxValue   : upper limit of histogram data; Required

Protect       : ON – statitics are not cleared by CLEAR or RESET

              : OFF – (default) is statistics are cleared

example    : hdata : HISTOGRAM = { Cells = 4, MinValue = 0,

           : MaxValue = 16 }; used as hdata = value;

%DISTRIBUTION : mechanism to create empirical functions

             : based upon user provided data pairs

             : same as MAPPING

(type)       : type is CONTINUOUS or DISCRETE interpolation

data list    : list of (x, y) data pairs separated by comas

example      : MyDist : DISTRIBUTION(DISCRETE) =

             :           { (0.1, 1), (0.4, 3), (1.0, 6) };

             : x =  MyDist(RANDOM)

%MAPPING      : Empirical function specification

             : see DISTRIBUTION

%ATTRIBUTES   : declaration of entity attributes of type real and array

             : all created entities are initialized to these values

example    : ATTRIBUTES =

           :  { cost = 0, Priority = 3, seq : ARRAY[<1,2,3>] = (0,0,12) };

%LABELS       : declaration of statement labels

example      : LABELS = { thru, prt, out};

%ENTITY     : declares an entity pointer variable

           : used to reference attributes of an entity other

           : than the active entity

           : see SEARCH, REMOVE, CREATE and SCHEDULE

example    : Aent : ENTITY; used as Aent[EntityNumber] – number

           : of current entity assigned to Aent

%SEQUENCE   : denotes a fixed collection of discrete values

           : < start .. end : mesh, repeats or individual elements>

           : if start > end then negative mesh is required

example    : < 1..4, 6, 7, 16..10:-1>

example    : s : SEQUENCE = <1, 2.3, 5>;

%STRING     : a list of characters enclosed in single quotes

example    : s : STRING = ‘Aa1’;

%INTERVAL   : discrete interval

           : [ Left Expression .. Right Expression: Mesh Expression]

           : default interval mesh is 1.

example    : range: Interval = [1 .. 2*i-1 :delta];

           : continuous interval – used only in boolean expressions

           : such as x IN [1, 3.5]

           : [ Left Expression , Right Expression ]

%REAL       : simple variables can take any (nonreserved) name,

           : are automatically of type real and must be initialized

           : applies to global variables and entity attributes

example    : X = 1.0; Yvalue = 0;

%ARRAY      : declaration for dimensioned variables, limit of 3 dimensions

           : ARRAY[ Dom1, Dom2, Dom3] = Array constant or All(value)

           : Index domain(s) must be sequences

           : initial values; can use in ATTRIBUTES

example    : a : ARRAY[ <1..3> ] = (0,0,0);

           : b : ARRAY[ <1..2>,<5,9,10> ] = ( (1,11,15), (3,-2,14) );

%TEXTFILE : associates disk file for user output

         :  with PRINT and PRINTLN

Name     : MSDOS file name (in single quotes),

         : special file names: PRN = printer, CON = screen

Status   : WRITE

example  : f:TEXTFILE = {Name = ‘Myfile.dta’, Status=write};

usage    : println{f, ‘ClockTime = ‘, CLOCKTIME:8:2};

%FUNCTION : user defined inline functions

         : name( argument list ) = Expression;

         : argument names are TEMPORARY variables and can not be

         : names already in use

         : the argument list can be empty

examples : f(a,b) = b*sin(a);

         : JobType() = Duniform(50,100);

%ALIAS      : synonym equate statement for system words

           : and previously defined user names

example    : ALIAS = { Machine = RESOURCE, Stop = HALT };

%ARRIVE     : schedules entities into system

Time       : interarrival time – expression (expr.); Required

OffSet     : delay time before arrive block becomes active;(0)

Limit      : maximum number of batches; (none)

Quantity   : number of entities in each arrival batch; (1)

example    : ARRIVE { Time = DUNIFORM(2,12), Limit = 5};

%DEPART     : removes entities from system

Quantity   : number substracted from StopCount each depart; (0)

example    : DEPART {}; or DEPART {Quantity = 3};

%WAIT       : causes entities to wait for specified time

Time       : time entity is held in block; Required

example    : WAIT { Time = EXPD(5*RANDOM) };

%SEIZE      : captures units from defined resource if available

Name       : resource name; Required

Units      : number of units requested; (1)

Rexcess    : transfer label if requested units are not available; (none)

Qexcess    : transfer label if 1 unit is not available in queue; (none)

example    : SEIZE { Name = Shop, Units = 2, Rexcess = label};

%RELEASE    : returns held units to resource

Name       : resource name: Required

Units      : number of units returned; (1)

example    : RELEASE { Name = Shop, Units = 1};

%ASSIGNMENT : used for assignment statements

example    : cost = cost + 1; x = CLOCKTIME;

%STARTSTAT  : tags entities with time of passing for statistics

Name       : statistics information name; Required

example    : STARTSTAT { Name = sysflow };

%ENDSTAT    : enters flow time from STARTSTAT into statistics

Name       : statistics information name; Required

example    : ENDSTAT { Name = sysflow };

%GOTO       : unconditional branch to block label

Destination: block label of destination; Required

example    : GOTO Inspect;

%IF         : conditional branch statement

              IF cond THEN TrueStmt ELSE FalseStmt;

              or

              IF cond THEN TrueStmt;

condition  : boolean expression (0 or 1 result);

example    : IF RANDOM <= 0.5 THEN  x = x + 1 ELSE GOTO myLabel;

%PRINT      : prints the argument list without a linefeed;

example    : PRINT {<f>,’ x = ‘,x:8:3,’ Time = ‘,CLOCKTIME:5:0};

           : where f is an optional user file name (TEXTFILE)

%PRINTLN    : prints argument list terminated by linefeed and CR.

example    : PRINTLN {<f>,PRIORITY:3:0,’ is an entity attribute’};

           : where f is an optional user file name (TEXTFILE)

%LINK       : places entity on specified chain list

Name       : chain name for linking, CHAIN must be defined; Req.

Cexcess    : if capacitated chain is full then branch to label

example    : LINK { Name = ShopQ, Cexcess = myLabel };

%UNLINK     : takes entities off of the specified chain list

Name       : chain name; Required

Quantity   : number of entities to unlink; Required

Destination: the location for unlinked entities; (NEXTBLOCK)

Condition  : boolean expression for unlinking entities; Optional

           : referenced attributes of candidate entity are used

example    : UNLINK { Name = ShopQ, Quantity = 1};

%COPY       : creates copies of the entity into a copy group

           : all the entities leave as independent entities

Quantity   : the number of copies to be made; Required

CopiesTo   : destination for copies; Required

example    : COPY { Quantity = 2, CopiesTo = label};

%COMBINE     : a group of entities is replaced by 1 entity

            : only the final entity leaves the block

Quantity    : number of entities to combine into one; Req.

UseAttribute: uses the attribute value to determine groupings

Decrement   : expression that decrements Quantity (1)

example     : COMBINE { Quantity = 4, Decrement = 2+x };

            : COMBINE { Quantity = 2, UseAttribute= group};

%PREEMPT    : interrupts seized resource units with larger preemptlevel

           : units are returned by a RELEASE block

Name       : resource name; Required

Units      : number of units requested; (1)

IfNoPreempt: transfer label if units not available; (none)

PreemptedTo: transfer label of preempted entities; (none)

Qexcess    : transfer label if entity can’t obtain resource and

             there is no room in the capacitated queue

Resume     : (ON,OFF) preempted entity uses time remaining or

           : restarts time when returned resource units; (ON)

example    : PREEMPT { Name = Shop, Units = 2, IfNoPreempt = label};

%SETGATE    : modifies named gate status

Name       : gate name for defined GATE from DEFINITION segment

Status     : (OPEN, CLOSE, or INVERT); Required

example    : SETGATE { Name = myGate , Status = OPEN };

%TESTGATE   : if named gate is closed, entity is queued until

           : a SETGATE causes gate to be opened

Name       : name of gate to be tested by entity; Required

IfClosed   : branch destination if gate is closed; (none)

%BUNDLE      : temporarily forms a surrogate to represent a group

            : of entities

Quantity    : number of entities to form one surrogate; Required

Surrogate   : (FIRST or LAST ), surrogate attributes; (LAST)

            : multiple levels of tempory groupings allowed

UseAttribute: uses the attribute value to determine groupings

Decrement   : expression that decrements Quantity (1)

example     : BUNDLE { Quantity = 3, Surrogate = First};

            : BUNDLE { Quantity = 8, UseAttribute= group, Decrement = 2+x};

%UNBUNDLE   : replaces the surrogate entity by the group it

           : represents, note that surrogate is destroyed

example    :  UNBUNDLE {};

%GATHER      : entites wait for Quantity of entities before leaving

Quantity    : number to collect before all are released; Req.

UseAttribute: uses the attribute value to determine groupings

Decrement   : expression that decrements Quantity (1)

example     : GATHER { Quantity = 8, Decrement = 2+x};

            : GATHER { Quantity = 2, UseAttribute= group};

%SEARCH     : scans a resource queue, named queue, chain or gate list

           : for first entity satisfying the given condition

           : returns entity pointer or rank

Name       : name of list to be searched; Required

Condition  : boolean expression compared against list entities

           : referenced attributes of candidate entity are used

Begin      : starting rank of scan; (1)

End        : last possible rank to test; (USED[name])

Rank       : variable name for returning Rank result; (none)

Entity     : entity typed variable name for returned pointer;(none)

           : either Rank or Entity parameter must be specified

           : no entity found then RANK = 0 and ENTITY = NIL

example    : SEARCH { Name = myQue, Entity = Aent, Rank = x

           :          Condition = xvalue – 1 };

%REMOVE     : removes a specified entity from a resource queue, named queue

           : gate, chain or future events list (EVENTCHAIN)

Name       : name of list; Required

Rank       : variable containing rank of entity to be removed;

Entity     : entity variable containing entity pointer;

           : either Rank or Entity parameter must be specified

           : note: system run time error occurs if entity not found

Destination: block label to which the removed entity is transfered

example    : REMOVE { Name = myQue, Entity = Aent, Destination = myLabel };

%WHILE      : WHILE BoolCond DO stmt;

           :    executes Stmt while BoolCond is true

           : Use BEGIN and END for compound statements

example    : WHILE cost < 10 DO cost = cost + 1;

%REPEAT     : REPEAT

                Stmt1; … StmtN;

              UNTIL BoolCond;

            : Stmt1 through StmtN are executed until BoolCond is true;

example     :  x = 0; REPEAT x = x + 1; UNTIL x = 10;

%DOCASES    :

           : DOCASES Expr OF

           :   Case X1: Stmt1; … Case Xn: StmtN;

           :   else – Else statement;  (optional)

             End;

           : where X1 … Xn are numbers, intervals, or sequences

example    : DOCASES i OF

           :    CASE     1: x = x + 1;

           :    CASE <2,3>: x + x + 2;

           :    CASE [4..5]: x = x + 3;

           :    ELSE x = 0;

           : END; “end of DOCASES”

%FOR    :

       : FOR (initial value; BoolExpr; updating expression) DO Stmt;

       : index variable can be global or attribute variable

       : the loop continues while BoolExpr is true

       : updating expression can be any expression

example: FOR (i = 0; i <= 5; i = i+1) DO Println {i:5};

%SCHEDULE   :

           : SCHEDULE{ Entity = ent, Time = expr, Destination = lab};

           : schedules the time of occurrence and point of entry for

           : entities that were created by the CREATE block.  CREATE and

           : SCHEDULE together allow total program control of arrivals

Entity     : refers to an entity variable initialized by a CREATE block

Time       : Time is the absolute activiation time for the entity

Destination: Destination is the statement label where the entity will

           : enter the model at the designated time

example    : SCHEDULE {Entity = Ent, Time = t, Destination = lab};

%CREATE  : program control of entity creation; used with SCHEDULE

        : CREATE { Entity = ent };

Entity  : ENTITY typed variable.  The actual pointer to the

        : created entity is placed into specified entity variable

        : CREATE must be used prior to SCHEDULE to create the entity

        : attributes; initialized values from ATTRIBUTES declaration

example : CREATE { Entity = MyEnt};

%HALT       : causes immediate termination of the simulation run

%ABORT      : causes the simulation system to halt and is most

           : useful within EXITLOGIC and multiple runs

%INTERRUPT  : program is suspended and the interrupt menu is displayed

           : Has same effect as pressing ESC during execution

%RESET      : provides program control for resetting statistics

%RANDOM     : returns zero-one uniform random variate/deviate

example    : myTime = RANDOM;

%DUNIFORM   : discrete uniform r.v.

           : Duniform( LowerLimit, UpperLimit)

             over the discrete interval [LowerLimit .. UpperLimit:1]

example    : myTime = DUNIFORM(1,6);

%CUNIFORM   : continuous uniform random variate

           : Cuniform(LowerLimit, UpperLimit)

           : over the continuous interval [LowerLimit, UpperLimit]

example    : myTime = 3*CUNIFORM(1,6);

%EXPD       : exponentially distributed random variate

           : EXPD(MeanTime)

example    : myTime = 6.0*EXPD(2.34) + 3.14;

%POISSON    : Poisson distributed random deviate

           : Poisson(MeanNumber)

example    : n = Poisson(6.17); (n is a whole number)

%BINOMIAL   : Binomial distributed random variate

           : Binomial(Number, Probability)

           : k = Binomial(10, 0.15); (k is whole number between 0 and 10)

%NORMAL     : Normal random variate

           : Normal(Mean, StdDev)

           : negative values may be returned!

example    : myTime = NORMAL(2.68,1.2) + 4;

example    : myTime = 0 MAX Normal(2.68,1.2);

%TRIANGULAR : Triangular random variate

           : Triangular(LowerLimit, Mode, UpperLimit)

example    : x = Triangular(1,8,15);

%WEIBULL    : Weibull distributed random variate

           : Weibull(Scale, Shape)

%ERLANG     : Erlang distributed random variate

           : Erlang(Mean, Order)

           :  Order = Number of convolutions

%GAMMA      : Gamma distributed random variate with parameters Scale and Shape

           : Gamma(Scale, Shape)

%LOGNORMAL  : LogNormally distributed random variate

           : LogNormal(Mean, Standard deviation)

%BETA       :Beta distributed random variate

           : Beta(Shape1, Shape2)

%NIL        : function which determines if an entity type variable

           : has been found

example    : NIL(xent) – where xent defined in ENTITY definition

%EVENTCHAIN: Predefined name for the system event chain

          : can be used in WatchList, SEARCH, and REMOVE

%CAPACITY  : system function to retrieve or change the capacity

              of a resource, queue or chain

            : CAPACITY[name] – name is resource, chain or named queue

            : CAPACITY[ ResName:QUEUE] to reference default resource Queue

            : only system attribute that can be changed by assignment

%USED  : system function to retrieve current contents of named construct

       : USED[name], to denote a resource queue use name:QUEUE

       : name is resource, queue, chain, gate, varStatistics, statistics

%RCURNUMBER : system function to retrieve number of entities in the resource

           : RCURNUMBER[name] – name is resource

           : units in resource use USED[name]

%AVAILABLE  : system function to retrieve available units of named construct

         : AVAILABLE[name] – name is resource, queue, chain, gate

%MAXNUMBER  : system function to retrieve maximum contents of named construct

     : MAXNUMBER[name] – name is resource, queue, chain, gate

     : to denote a resource queue use name:QUEUE

%LASTTIME  : system function to retrieve last time of named construct undate

     : LASTTIME[name], to denote a resource queue use name:QUEUE

     : name is resource, queue, chain, gate, varStatistics, statistics

%CUMNUMBER  : system function to retrieve cumulative entity entries

     : CUMNUMBER[name],  to denote a resource queue use name:QUEUE

     : name is resource, queue, chain, gate, varStatistics, statistics

%CUMVALUE  : system function to retrieve cumulative value of entries

       : CUMVALUE[name] – name is a varStatistics typed variable

%MAXVALUE  : system function to retrieve maximum value of entries

       : MAXVALUE[name] – name is a varStatistics typed variable

%CUMZEROS  : system function to retrieve number of zero flowtime entries

       : CUMZEROS[name] – name is a Statistics typed variable

%CUMPRODUCTNT : system function to retrieve cumulative number times time

     : statistics data, used in mean duration and mean contents computations

     : CUMPRODUCTNT[name], to denote a resource queue use name:QUEUE

     : name is queue, chain, gate

%CUMPRODUCTVT : system function to retrieve cumulative value times time

     : statistics data, used in mean duration and mean contents computations

     : CumProductVT[name]

     : name is resource, varStatistics, statistics

%BLOCKTOTAL[label] : current value of total entries into block

%BLOCKCURRENT[label] : current number of entities in block

%CLOCKTIME  : system clock time at any point in simulation

%PREEMPTLEVEL : entity read and write attribute used in preempt block

             : to determine if current resource holding entity

             : can be preempted, smaller numbers have higher priority

%RESUMETIME : read only, has remaining wait time if preempted

%ENTITYNUMBER : creation number of the entity

%CURRENTBLOCK : sequential statementnumber for the location of the

               active entity

%NEXTBLOCK  : default label for the next sequential statement

%WATCHCHAR : entity attribute with single character to use in animation

          : activated by assigning character to WATCHCHAR

example   : WATCHCHAR = ‘A’;

Filed Under: Uncategorized

Pages

  • Contact
  • Lee L. Lowery, Jr., PhD, P.E.
  • Office Hours

© 2016–2025 Lee L. Lowery, Jr. Log in

Texas A&M Engineering Experiment Station Logo
  • College of Engineering
  • Facebook
  • Twitter
  • State of Texas
  • Open Records
  • Risk, Fraud & Misconduct Hotline
  • Statewide Search
  • Site Links & Policies
  • Accommodations
  • Environmental Health, Safety & Security
  • Employment