PetriNets.Extensions

PetriNets.Extensions.TDelay PetriNets.Extensions.TNoCondition PetriNets.Extensions.P10Capacity PetriNets.Extensions.P01Capacity PetriNets.Extensions.P11Capacity PetriNets.Extensions.TDelayExp PetriNets.Extensions.Place11B PetriNets.Extensions.SynchronizeNoCondition PetriNets.Extensions.ParallelNoCondition PetriNets.Extensions.TDelayWeibull PetriNets.Extensions.TDelayExpBIRNG PetriNets.Extensions.TDelayNormalBIRNG PetriNets.Extensions.TDelayUniformBIRNG PetriNets.Extensions.TDelayWeibullBIRNG PetriNets.Extensions.TDelayUniform PetriNets.Extensions.TDelayNormal

Information

See Knuth D.E. (1981). The Art of Computer Programming,
Seminumerical Algorithms, vol. 2, 2nd ed., Addison-Wesley, U.S.A.
 as a reference to random number generation.


PetriNets.Extensions.TDelayExp PetriNets.Extensions.TDelayExp

Transition with one input and one output connection

PetriNets.Extensions.TDelayExp

Parameters

NameDefaultDescription
mean10Exponential mean
seed1973272912 

Modelica definition

model TDelayExp "Transition with one input and one output connection"

  parameter Real mean=10 "Exponential mean";
  parameter Integer seed=1973272912;
  
  Boolean activated;
  Boolean delay_passed;
  Boolean fire;
  
  Real last_activation_time;
  Real delay;
  
  Integer Xi(start=seed);
  Integer Xiplus;
  Integer m=2147483647;
  //(2^31) - 1
  Integer a=7^5;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  //activation of transition
  activated = inTransition.state;
  
  //activated and delay passed
  delay_passed = activated and ((time - delay) > last_activation_time);
  
  //fire command
  fire = activated and delay_passed and not outTransition.state;
  
  //propagate firing to in and output places
  inTransition.fire = fire;
  outTransition.set = fire;
  
  //set activation time
algorithm
  when activated then
    last_activation_time := time;
    //Multiplicative Linear Congruential Method 
    Xiplus := mod(a*Xi, m);
    delay := -mean*ln(Xiplus/m);
    Xi := Xiplus;
    

      //The built in function only runs for a certain number of samples and then 
    //breaks down
    //delay := -mean*ln(RandomUniform(time));
  end when;
end TDelayExp;

PetriNets.Extensions.TDelayNormal PetriNets.Extensions.TDelayNormal

Transition with one input and one output connection

PetriNets.Extensions.TDelayNormal

Parameters

NameDefaultDescription
mean10Mean of normal distribution
standardDev1Standard deviation of normal distribution
seed11973272912 
seed228864 

Modelica definition

model TDelayNormal
  "Transition with one input and one output connection"
  parameter Real mean=10 "Mean of normal distribution";
  parameter Real standardDev=1
    "Standard deviation of normal distribution";
  parameter Integer seed1=1973272912;
  parameter Integer seed2=28864;
  
  Boolean activated;
  Boolean delay_passed;
  Boolean fire;
  
  Real last_activation_time;
  Real delay;
  
  Integer X1(start=seed1);
  Integer X1plus;
  Integer X2(start=seed2);
  Integer X2plus;
  Real YnormalStandard;
  Real Ynormal;
  Integer m=2147483647;
  //(2^31) - 1
  Integer a=7^5;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  //activation of transition
  activated = inTransition.state;
  
  //activated and delay passed
  delay_passed = activated and ((time - delay) > last_activation_time);
  
  //fire command
  fire = activated and delay_passed and not outTransition.state;
  
  //propagate firing to in and output places
  inTransition.fire = fire;
  outTransition.set = fire;
  
  //set activation time
algorithm
  when activated then
    last_activation_time := time;
    //Multiplicative Linear Congruential Method 
    X1plus := mod(a*X1, m);
    X2plus := mod(a*X2, m);
    //Box-Mueller transformation method for normal distribution
    YnormalStandard := sqrt(-2*ln(X1plus/m))*cos(2*Modelica.Constants.pi*(
      X2plus/m));
    Ynormal := mean + standardDev*YnormalStandard;
    delay := Ynormal;
    X1 := X1plus;
    X2 := X2plus;
  end when;
end TDelayNormal;

PetriNets.Extensions.TDelayExpBIRNG PetriNets.Extensions.TDelayExpBIRNG

Transition with one input and one output connection

PetriNets.Extensions.TDelayExpBIRNG

Parameters

NameDefaultDescription
mean10Exponential mean

Modelica definition

model TDelayExpBIRNG
  "Transition with one input and one output connection"
  
  parameter Real mean=10 "Exponential mean";
  
  Boolean activated;
  Boolean delay_passed;
  Boolean fire;
  
  Real last_activation_time;
  Real delay;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  //activation of transition
  activated = inTransition.state;
  
  //activated and delay passed
  delay_passed = activated and ((time - delay) > last_activation_time);
  
  //fire command
  fire = activated and delay_passed and not outTransition.state;
  
  //propagate firing to in and output places
  inTransition.fire = fire;
  outTransition.set = fire;
  
  //set activation time
algorithm
  when activated then
    last_activation_time := time;
    //The built in function only runs for a certain number (quite large)
    // of samples and then miraculously creates extremly large values!
    delay := -mean*ln(RandomUniform(time));
  end when;
end TDelayExpBIRNG;

PetriNets.Extensions.TDelayNormalBIRNG PetriNets.Extensions.TDelayNormalBIRNG

Transition with one input and one output connection

PetriNets.Extensions.TDelayNormalBIRNG

Parameters

NameDefaultDescription
center5.0Normal around center
standardDev1.0Standard deviation of the normal distribution

Modelica definition

model TDelayNormalBIRNG
  "Transition with one input and one output connection"
  parameter Real center=5.0 "Normal around center";
  parameter Real standardDev=1.0
    "Standard deviation of the normal distribution";
  
  Boolean activated;
  Boolean delay_passed;
  Boolean fire;
  
  Real last_activation_time;
  Real delay;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  //activation of transition
  activated = inTransition.state;
  
  //set activation time
  when activated then
    last_activation_time = time;
    delay = center + standardDev*(RandomNormal(time));
  end when;
  
  //activated and delay passed
  delay_passed = activated and ((time - delay) > last_activation_time);
  
  //fire command
  fire = activated and delay_passed and not outTransition.state;
  
  //propagate firing to in and output places
  inTransition.fire = fire;
  outTransition.set = fire;
end TDelayNormalBIRNG;

PetriNets.Extensions.TDelay PetriNets.Extensions.TDelay

Transition with one input and one output connection

PetriNets.Extensions.TDelay

Parameters

NameDefaultDescription
delay5 

Modelica definition

model TDelay "Transition with one input and one output connection"
  parameter Real delay=5;
  
  Boolean activated;
  Boolean delay_passed;
  Boolean fire;
  
  Real last_activation_time;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  
  //activation of transition
  activated = inTransition.state;
  
  //set activation time
  when activated then
    last_activation_time = time;
  end when;
  
  //activated and delay passed
  delay_passed = activated and ((time - delay) > last_activation_time);
  
  //fire command
  fire = activated and delay_passed and not outTransition.state;
  
  //propagate firing to in and output places
  inTransition.fire = fire;
  outTransition.set = fire;
  
end TDelay;

PetriNets.Extensions.P10Capacity PetriNets.Extensions.P10Capacity

Place with one input and one output transition

PetriNets.Extensions.P10Capacity

Parameters

NameDefaultDescription
num_tokens_start0Initial number of tokens
N1Capacity limit for tokens

Modelica definition

model P10Capacity "Place with one input and one output transition"
  parameter Integer num_tokens_start=0 "Initial number of tokens";
  parameter Integer N=1 "Capacity limit for tokens";
  
  Integer num_tokens(start=num_tokens_start)
    "number of tokens present on the place";
  Boolean full;
  
  Integer new_num_tokens(start=num_tokens_start);
  Boolean tokenin;
public
  PetriNets.Interfaces.SetPortIn inTransition;
equation
  // Set new token number for next iteration
  num_tokens = pre(new_num_tokens);
  
  tokenin = inTransition.set and not full;
  
  when tokenin then
    new_num_tokens = num_tokens + 1;
  end when;
  
  full = num_tokens == N;
  
  // Report state to input and output transitions
  inTransition.state = full and not pre(tokenin);
end P10Capacity;

PetriNets.Extensions.P01Capacity PetriNets.Extensions.P01Capacity

Place with one input and one output transition

PetriNets.Extensions.P01Capacity

Parameters

NameDefaultDescription
num_tokens_start0Initial number of tokens
N1Capacity limit for tokens

Modelica definition

model P01Capacity "Place with one input and one output transition"
  parameter Integer num_tokens_start=0 "Initial number of tokens";
  parameter Integer N=1 "Capacity limit for tokens";
  
  Integer num_tokens(start=num_tokens_start)
    "number of tokens present on the place";
  Boolean empty;
  
  Integer new_num_tokens(start=num_tokens_start);
  Boolean tokenout;
  Interfaces.FirePortOut outTransition;
equation
  // Set new token number for next iteration
  num_tokens = pre(new_num_tokens);
  
  tokenout = outTransition.fire and not empty;
  
  when tokenout then
    new_num_tokens = num_tokens - 1;
  end when;
  
  empty = num_tokens == 0;
  
  // Report state to input and output transitions
  outTransition.state = not empty and not pre(tokenout);
end P01Capacity;

PetriNets.Extensions.P11Capacity PetriNets.Extensions.P11Capacity

Place with one input and one output transition

PetriNets.Extensions.P11Capacity

Parameters

NameDefaultDescription
num_tokens_start0Initial number of tokens
N1Capacity limit for tokens

Modelica definition

model P11Capacity "Place with one input and one output transition"
  parameter Integer num_tokens_start=0 "Initial number of tokens";
  parameter Integer N=1 "Capacity limit for tokens";
  
  Integer num_tokens(start=num_tokens_start)
    "number of tokens present on the place";
  Boolean full;
  Boolean empty;
  
  Integer new_num_tokens(start=num_tokens_start);
  Boolean tokenin;
  Boolean tokenout;
  Boolean tokeninout;
  
  Real Qtotal;
  Real Qavg;
public
  PetriNets.Interfaces.SetPortIn inTransition;
  PetriNets.Interfaces.FirePortOut outTransition;
  Modelica.Blocks.Interfaces.OutPort outTokens;
  Modelica.Blocks.Interfaces.BooleanOutPort Bchange;
equation
  // Set new token number for next iteration
  num_tokens = pre(new_num_tokens);
  
  tokenin = inTransition.set and not full and not outTransition.fire;
  tokenout = outTransition.fire and not empty and not inTransition.set;
  tokeninout = inTransition.set and outTransition.fire;
  
  when {tokenin,tokenout,tokeninout} then
    new_num_tokens = if edge(tokenin) then num_tokens + 1 else if edge(tokenout
      ) then num_tokens - 1 else num_tokens;
    
  end when;
  
  full = num_tokens == N;
  empty = num_tokens == 0;
  
  // Report state to input and output transitions
  inTransition.state = full and not pre(tokenin) and not pre(tokeninout);
  outTransition.state = not empty and not pre(tokenout) and not pre(tokeninout)
    ;
  
  outTokens.signal[1] = num_tokens;
  Bchange.signal[1] = not (num_tokens == new_num_tokens);
  
  der(Qtotal) = num_tokens;
  Qavg = Qtotal/(time + 1e-3);
end P11Capacity;

PetriNets.Extensions.TNoCondition PetriNets.Extensions.TNoCondition

Transition with one input and one output connection

PetriNets.Extensions.TNoCondition

Modelica definition

model TNoCondition
  "Transition with one input and one output connection"
  Boolean fire;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  fire = inTransition.state and not outTransition.state;
  inTransition.fire = fire;
  outTransition.set = fire;
end TNoCondition;

PetriNets.Extensions.Place11B PetriNets.Extensions.Place11B

Place with one input and one output transition

PetriNets.Extensions.Place11B

Parameters

NameDefaultDescription
initialStatefalseInitial value of state

Modelica definition

model Place11B "Place with one input and one output transition"
  parameter Boolean initialState=false "Initial value of state";
  Boolean state(final start=initialState) "State of place";
protected
  Boolean newState(final start=initialState);
public
  PetriNets.Interfaces.SetPortIn inTransition;
  PetriNets.Interfaces.FirePortOut outTransition;
  Modelica.Blocks.Interfaces.BooleanOutPort BState;
equation
  // Set new state for next iteration
  state = pre(newState);
  newState = inTransition.set or state and not outTransition.fire;
  
  // Report state to input and output transitions
  inTransition.state = state;
  outTransition.state = state;
  
  BState.signal[1] = state;
end Place11B;

PetriNets.Extensions.SynchronizeNoCondition PetriNets.Extensions.SynchronizeNoCondition

Transition with two input and one output connections

PetriNets.Extensions.SynchronizeNoCondition

Modelica definition

model SynchronizeNoCondition
  "Transition with two input and one output connections"
  Boolean fire;
  PetriNets.Interfaces.FirePortIn inTransition1;
  PetriNets.Interfaces.FirePortIn inTransition2;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  fire = inTransition1.state and inTransition2.state and not
    outTransition.state;
  inTransition1.fire = fire;
  inTransition2.fire = fire;
  outTransition.set = fire;
end SynchronizeNoCondition;

PetriNets.Extensions.ParallelNoCondition PetriNets.Extensions.ParallelNoCondition

Transition with one input and two output connections

PetriNets.Extensions.ParallelNoCondition

Modelica definition

model ParallelNoCondition
  "Transition with one input and two output connections"
  Boolean fire;
  
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition1;
  PetriNets.Interfaces.SetPortOut outTransition2;
equation
  fire = inTransition.state and not (outTransition1.state or
    outTransition2.state);
  inTransition.fire = fire;
  outTransition1.set = fire;
  outTransition2.set = fire;
end ParallelNoCondition;

PetriNets.Extensions.TDelayWeibull PetriNets.Extensions.TDelayWeibull

Transition with one input and one output connection

PetriNets.Extensions.TDelayWeibull

Parameters

NameDefaultDescription
alpha1Weibull shape parameter alpha
beta2Weibull shape parameter beta
seed1973272912 

Modelica definition

model TDelayWeibull
  "Transition with one input and one output connection"
  parameter Real alpha=1 "Weibull shape parameter alpha";
  parameter Real beta=2 "Weibull shape parameter beta";
  parameter Integer seed=1973272912;
  
  Boolean activated;
  Boolean delay_passed;
  Boolean fire;
  
  Real last_activation_time;
  Real delay;
  
  Integer Xi(start=seed);
  Integer Xiplus;
  Integer m=2147483647;
  //(2^31) - 1
  Integer a=7^5;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  //activation of transition
  activated = inTransition.state;
  
  //activated and delay passed
  delay_passed = activated and ((time - delay) > last_activation_time);
  
  //fire command
  fire = activated and delay_passed and not outTransition.state;
  
  //propagate firing to in and output places
  inTransition.fire = fire;
  outTransition.set = fire;
  
  //set activation time
algorithm
  when activated then
    last_activation_time := time;
    //Multiplicative Linear Congruential Method 
    Xiplus := mod(a*Xi, m);
    delay := (-(1/alpha)*ln(1 - Xiplus/m))^(1/beta);
    Xi := Xiplus;
    

      //The built in function only runs for a certain number of samples and then 
    //breaks down
    //delay := -mean*ln(RandomUniform(time));
  end when;
end TDelayWeibull;

PetriNets.Extensions.TDelayUniformBIRNG PetriNets.Extensions.TDelayUniformBIRNG

Transition with one input and one output connection

PetriNets.Extensions.TDelayUniformBIRNG

Parameters

NameDefaultDescription
min0Uniform between min..max
max1Uniform between min..max

Modelica definition

model TDelayUniformBIRNG
  "Transition with one input and one output connection"
  parameter Real min=0 "Uniform between min..max";
  parameter Real max=1 "Uniform between min..max";
  
  Boolean activated;
  Boolean delay_passed;
  Boolean fire;
  
  Real last_activation_time;
  Real delay;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  //activation of transition
  activated = inTransition.state;
  
  //set activation time
  when activated then
    last_activation_time = time;
    delay = min + (max - min)*(RandomUniform(time));
  end when;
  
  //activated and delay passed
  delay_passed = activated and ((time - delay) > last_activation_time);
  
  //fire command
  fire = activated and delay_passed and not outTransition.state;
  
  //propagate firing to in and output places
  inTransition.fire = fire;
  outTransition.set = fire;
end TDelayUniformBIRNG;

PetriNets.Extensions.TDelayWeibullBIRNG PetriNets.Extensions.TDelayWeibullBIRNG

Transition with one input and one output connection

PetriNets.Extensions.TDelayWeibullBIRNG

Parameters

NameDefaultDescription
alpha1Weibull shape parameter alpha
beta2Weibull shape parameter beta

Modelica definition

model TDelayWeibullBIRNG
  "Transition with one input and one output connection"
  parameter Real alpha=1 "Weibull shape parameter alpha";
  parameter Real beta=2 "Weibull shape parameter beta";
  
  Boolean activated;
  Boolean delay_passed;
  Boolean fire;
  
  Real last_activation_time;
  Real delay;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  //activation of transition
  activated = inTransition.state;
  
  //activated and delay passed
  delay_passed = activated and ((time - delay) > last_activation_time);
  
  //fire command
  fire = activated and delay_passed and not outTransition.state;
  
  //propagate firing to in and output places
  inTransition.fire = fire;
  outTransition.set = fire;
  
  //set activation time
algorithm
  when activated then
    last_activation_time := time;
    delay := (-(1/alpha)*ln(1 - RandomUniform(time)))^(1/beta);
  end when;
end TDelayWeibullBIRNG;

PetriNets.Extensions.TDelayUniform PetriNets.Extensions.TDelayUniform

Transition with one input and one output connection

PetriNets.Extensions.TDelayUniform

Parameters

NameDefaultDescription
min0Uniform between min..max
max1Uniform between min..max
seed1973272912 

Modelica definition

model TDelayUniform
  "Transition with one input and one output connection"
  parameter Real min=0 "Uniform between min..max";
  parameter Real max=1 "Uniform between min..max";
  parameter Integer seed=1973272912;
  
  Boolean activated;
  Boolean delay_passed;
  Boolean fire;
  
  Real last_activation_time;
  Real delay;
  
  Integer Xi(start=seed);
  Integer Xiplus;
  Integer m=2147483647;
  //(2^31) - 1
  Integer a=7^5;
  PetriNets.Interfaces.FirePortIn inTransition;
  PetriNets.Interfaces.SetPortOut outTransition;
equation
  //activation of transition
  activated = inTransition.state;
  
  //activated and delay passed
  delay_passed = activated and ((time - delay) > last_activation_time);
  
  //fire command
  fire = activated and delay_passed and not outTransition.state;
  
  //propagate firing to in and output places
  inTransition.fire = fire;
  outTransition.set = fire;
  
  //set activation time
algorithm
  when activated then
    last_activation_time := time;
    Xiplus := mod(a*Xi, m);
    delay := min + (max - min)*(Xiplus/m);
    Xi := Xiplus;
  end when;
end TDelayUniform;

HTML-documentation generated by Dymola Tue Apr 30 22:45:11 2002 .