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
- Protected
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[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- 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 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[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- 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() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- 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(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- val x: Double
- val y: Double
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated