class ArcD extends PetriNetRules with Identifiable
The ArcD class represents an arc connecting continuous place with a
transition. If incoming is true the arc is from the place to transition,
otherwise it is from the transition to the place (outgoing).
- Alphabetic
- By Inheritance
- ArcD
- Identifiable
- Error
- PetriNetRules
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
ArcD(place: PlaceD, transition: Transition, incoming: Boolean, minFluids: VectorD, rates: VectorD = null, derv: Array[Derivative] = null, testArc: Boolean = false, scaleFactor: Double = 1.0)
- place
the continuous place at one end of the arc
- transition
the transition the other end of the arc
- incoming
whether the arc goes into a transition
- minFluids
minimum amount of fluid to transport over the arc
- rates
the rate vector for the linear flow model
- derv
the array of derivative functions for ODE's
- testArc
whether the arc is a test arc meaning the tokens/fluids stay
- scaleFactor
the scale factor for the firing delay
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
_fluidFlow(fluids: VectorD, time: Double, firingDelay: Double): VectorD
Compute the amount of fluid of each color to flow over 'this' arc.
Compute the amount of fluid of each color to flow over 'this' arc.
- fluids
the amount of fluid available
- time
the current time
- firingDelay
the time it takes for the transition to fire
-
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
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
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] )
-
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
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- Identifiable → AnyRef → Any
-
val
id: Int
- Definition Classes
- Identifiable
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
me: String
- Definition Classes
- Identifiable
- val minFluids: VectorD
-
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
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- val place: PlaceD
-
def
simType: String
- Definition Classes
- Identifiable
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
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
- 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
- val transition: 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
- @throws( ... )