class Transition extends PQItem with Ordered[Transition] with PetriNetRules with Identifiable
The Transition class represents a timed transition.
- Alphabetic
- By Inheritance
- Transition
- PetriNetRules
- Ordered
- Comparable
- PQItem
- Identifiable
- Error
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
Transition(x: Double, y: Double, firingDist: Variate, colors: Array[Color])
- x
the x-coordinate for 'this' transition
- y
the y-coordinate for 'this' transition
- firingDist
the random variate for the firing distribution
- colors
the colors of the tokens (needed for firing rules)
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
<(that: Transition): Boolean
- Definition Classes
- Ordered
-
def
<=(that: Transition): Boolean
- Definition Classes
- Ordered
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
>(that: Transition): Boolean
- Definition Classes
- Ordered
-
def
>=(that: Transition): Boolean
- Definition Classes
- Ordered
-
val
actTime: Double
- Definition Classes
- PQItem
-
def
addFluids(_fluids: VectorD): Unit
Add fluids to 'this' transition.
Add fluids to 'this' transition.
- _fluids
the fluid vector to add
-
def
addTokens(_tokens: VectorI): Unit
Add tokens to 'this' transition.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
calcFiringDelay(v: Variate, w_t: VectorD, t: VectorI, w_f: VectorD, f: VectorD): Double
Function to compute the delay in firing a transition.
Function to compute the delay in firing a transition. The base time is given by a random variate. This is adjusted by weight vectors multiplying the number of aggregate tokens and the aggregate amount of fluids summed over all input places: delay = v + w_t * t + w_f * f.
- v
the random variate used to compute base firing time
- w_t
the weight for the token vector
- t
the aggregate token vector (summed over all input places)
- w_f
the weight for the fluid vector
- f
the aggregate fluid level vector (summed over all input places)
- Definition Classes
- PetriNetRules
-
def
checkGuard: Boolean
Check the incoming arcs from discrete place for enough tokens of the right colors and the incoming arcs from continuous places for enough fluid of the right colors.
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
compare(tr2: Transition): Int
Compare 'this' transition to 'tr2' based on firing time.
Compare 'this' transition to 'tr2' based on firing time.
- tr2
the other transition
- Definition Classes
- Transition → Ordered
-
def
compare(other: PQItem): Int
- Definition Classes
- PQItem
-
def
compareTo(that: Transition): Int
- Definition Classes
- Ordered → Comparable
-
def
connect(_pnet: PetriNet, _inI: Array[ArcI], _inD: Array[ArcD], _outI: Array[ArcI], _outD: Array[ArcD]): Unit
Connect 'this' transition to all the incoming and outgoing arcs as well as the containing Petri net.
Connect 'this' transition to all the incoming and outgoing arcs as well as the containing Petri net.
- _pnet
the containing Petri net
- _inI
the incoming arcs from discrete/
Intplaces- _inD
the incoming arcs from continuous/
Doubleplaces- _outI
the outgoing arcs to discrete/
Intplaces- _outD
the outgoing arcs to continuous/
Doubleplaces
-
def
connect(_pnet: PetriNet, _in: Array[ArcD], _out: Array[ArcD]): Unit
Connect 'this' transition to all the incoming and outgoing continuous arcs as well as the containing Petri net.
Connect 'this' transition to all the incoming and outgoing continuous arcs as well as the containing Petri net.
- _pnet
the containing Petri net
- _in
the incoming arcs from continuous/
Doubleplaces- _out
the outgoing arcs to continuous/
Doubleplaces
-
def
connect(_pnet: PetriNet, _in: Array[ArcI], _out: Array[ArcI]): Unit
Connect 'this' transition to all the incoming and outgoing discrete arcs as well as the containing Petri net.
Connect 'this' transition to all the incoming and outgoing discrete arcs as well as the containing Petri net.
- _pnet
the containing Petri net
- _in
the incoming arcs from discrete/
Intplaces- _out
the outgoing arcs to discrete/
Intplaces
-
var
cqueue: ConcurrentLinkedQueue[AnimateCommand]
The animation command queue
-
def
enable(): Double
Enable 'this' transition by computing the firing delay.
Enable 'this' transition by computing the firing delay. Should immediately place it on the time ordered firing list. Also, move tokens/fluids from input places to 'this' transition.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(that: Any): Boolean
- Definition Classes
- Identifiable → AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
fire(): Unit
Fire 'this' transition by moving the requisite number and color of tokens from 'this' transition to each outgoing discrete place and the requisite amount and color of fluid to each outgoing continuous place.
-
var
firingDelay: Double
The firing delay for 'this' transition
-
final
def
flaw(method: String, message: String): Unit
- Definition Classes
- Error
-
def
fluidFlow(f: VectorD, derv: Array[Derivative], t0: Double, d: Double): VectorD
Compute the amount of fluid to flow over an arc according to the system of first-order Ordinary Differential Equation 'ODE's: "integral 'derv' from t0 to t".
Compute the amount of fluid to flow over an arc according to the system of first-order Ordinary Differential Equation 'ODE's: "integral 'derv' from t0 to t". Supports ODE base flow models.
- f
the fluid vector (amount of fluid per color)
- derv
the array of derivative functions
- t0
the current time
- d
the time delay
- Definition Classes
- PetriNetRules
-
def
fluidFlow(f: VectorD, b: VectorD, r: VectorD = null, d: Double = 0): VectorD
Compute the amount of fluid to flow over an arc according to the vector expression: b + r * (f-b) * d.
Compute the amount of fluid to flow over an arc according to the vector expression: b + r * (f-b) * d. If r is 0, returns b. Supports linear (w.r.t. time delay) and constant (d == 0) flow models.
- f
the fluid vector (amount of fluid per color)
- b
the constant vector for base fluid flow
- r
the rate vector (amounts of fluids per unit time)
- d
the time delay
- Definition Classes
- PetriNetRules
-
var
fluids: VectorD
Fluid vector for transition
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- Identifiable → AnyRef → Any
-
val
id: Int
- Definition Classes
- Identifiable
-
var
inD: Array[ArcD]
Arcs incoming from continuous places
-
var
inI: Array[ArcI]
Arcs incoming from discrete places
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
var
locked: Boolean
A transition is locked from the time it is enabled until it fires
-
def
me: String
- Definition Classes
- Identifiable
-
def
name: String
- Definition Classes
- Identifiable
-
def
name_=(name: String): Unit
- Definition Classes
- Identifiable
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
var
outD: Array[ArcD]
Arcs outgoing to continuous places
-
var
outI: Array[ArcI]
Arcs outgoing to discrete places
-
var
pnet: PetriNet
The containing Petri net
-
def
simType: String
- Definition Classes
- Identifiable
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
takeFluids(_fluids: VectorD): Unit
Take fluids from 'this' transition.
Take fluids from 'this' transition.
- _fluids
the fluid vector to take away
-
def
takeTokens(_tokens: VectorI): Unit
Take tokens from 'this' transition.
-
def
thresholdD(f: VectorD, b: VectorD): Boolean
Return whether the vector inequality is true: f >= b.
Return whether the vector inequality is true: f >= b. The firing threshold should be checked for every incoming arc. If all return true, the transition should fire.
- f
The fluid vector (amount of fluid per color)
- b
The base constant vector
- Definition Classes
- PetriNetRules
-
def
thresholdI(t: VectorI, b: VectorI): Boolean
Return whether the vector inequality is true: t >= b.
Return whether the vector inequality is true: t >= b. The firing threshold should be checked for every incoming arc. If all return true, the transition should fire.
- t
the token vector (number of tokens per color)
- b
the base constant vector
- Definition Classes
- PetriNetRules
-
def
toString(): String
- Definition Classes
- PQItem → AnyRef → Any
-
def
tokenFlow(t: VectorI, b: VectorI, r: VectorI = null, d: Double = 0): VectorI
Compute the number of tokens to flow over an arc according to the vector expression: b + r * (t-b) * d.
Compute the number of tokens to flow over an arc according to the vector expression: b + r * (t-b) * d. If d is 0, returns b. Supports linear (w.r.t. time delay) and constant (d == 0) flow models.
- t
the token vector (number of tokens per color)
- b
the constant vector for base token flow
- r
the rate vector (number of tokens per unit time)
- d
the time delay
- Definition Classes
- PetriNetRules
-
var
tokens: VectorI
Token vector for transition
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- val x: Double
- val y: Double