} } // event adapter
/**********************************************************/
/* All internal events shall be private, */
/* and inherite from InternalEvent as defined above */
/**********************************************************/
//private class InitEvent : InternalEvent
//{
// public override void Invoke()
// {
// Schedule(This.Queueing1.Enqueue(), TimeSpan.FromMinutes(5));
// }
//}
//private class FinishEvent : InternalEvent
//{
// public override void Invoke()
// {
// This.TotalNCompleted++;
// }
//}
#endregion
#region Input Events - Getters
/***************************************************************/
/* Methods returning an InternalEvent as O2DESNet.Event, */
/* with parameters for the objects to be passed in. */
/* Note that the InternalEvent shall always carry This = this. */
/***************************************************************/
//public Event Input(TLoad load) { return new InternalEvent { This = this, Load = load }; }
#endregion
#region Output Events - Reference to Getters
/***********************************************************************/
/* List of functions that maps outgoing objects to an external event. */
/* Note that the mapping is specified only in external structure. */
/***********************************************************************/
//public List<Func<TLoad, Event>> OnOutput { get; private set; } = new List<Func<TLoad, Event>>();
#endregion
public Modular_TandemQ(Statics config, int seed, string tag = null) : base(config, seed, tag)
{
// 子模块（动态属性）的初始化
Generator = new Generator(Config.Generator, DefaultRS.Next());
Queueing1 = new Queueing(Config.Queueing1, DefaultRS.Next());
Server1 = new Server(Config.Server1, DefaultRS.Next());
Queueing2 = new Queueing(Config.Queueing2, DefaultRS.Next());
Server2 = new Server(Config.Server2, DefaultRS.Next());
// 连接子模块之间的输出和输入事件
Generator.OnArrive.Add(Queueing1.Enqueue);
//Generator.OnArrive.Add(() => Queueing.Enqueue());
Queueing1.OnDequeue.Add(Server1.Start);
Server1.OnDepart.Add(Queueing2.Enqueue);
Queueing2.OnDequeue.Add(Server2.Start);
Server2.OnStateChg.Add(() => Queueing2.UpdToDequeue(Server2.Vacancy > 0));
Queueing2.OnStateChg.Add(() => Server1.UpdToDepart(Queueing2.Vacancy > 0));
Server1.OnStateChg.Add(() => Queueing1.UpdToDequeue(Server1.Vacancy > 0));
//Server1.OnDepart.Add(() => new FinishEvent { This = this });
// 初始化事件
InitEvents.AddRange(Generator.InitEvents);
//InitEvents.Add(new InitEvent { This = this });
}
public MMnQueue_Modular(double hourlyArrivalRate, double hourlyServiceRate, int nServers, int seed = 0)
: base(seed)
{
HourlyArrivalRate = hourlyArrivalRate;
HourlyServiceRate = hourlyServiceRate;
Generator = AddChild(new Generator(new Generator.Statics
{
InterArrivalTime = rs => Exponential.Sample(rs, TimeSpan.FromHours(1 / HourlyArrivalRate))
}, DefaultRS.Next()));
Queue = AddChild(new Queue(double.PositiveInfinity, DefaultRS.Next()));
Server = AddChild(new Server(new Server.Statics
{
Capacity = nServers,
ServiceTime = (rs, load) => Exponential.Sample(rs, TimeSpan.FromHours(1 / HourlyServiceRate)),
}, DefaultRS.Next()));
Generator.OnArrive += () => Queue.RqstEnqueue(new Load());
Generator.OnArrive += Arrive;
Queue.OnEnqueued += Server.RqstStart;
Server.OnStarted += Queue.Dequeue;
Server.OnReadyToDepart += Server.Depart;
Server.OnReadyToDepart += load => Depart();
HC_InSystem = AddHourCounter();
/// Initial event
Generator.Start();
}
public PingPongGame(Statics config, int seed = 0) : base(seed)
{
Config = config;
Player1 = AddChild(new PingPongPlayer(Config.Player1, DefaultRS.Next()));
Player2 = AddChild(new PingPongPlayer(Config.Player2, DefaultRS.Next()));
Player1.OnSend += Player2.Receive;
Player2.OnSend += Player1.Receive;
Schedule(Player1.Receive);
}
public MMcQueue_Pull(Statics config, int seed = 0) : base(seed)
{
Config = config;
Generator = AddChild(new Generator(Config.HourlyArrivalRate, DefaultRS.Next()));
Queue = AddChild(new Queue());
Server = AddChild(new Server(Config.Capacity, Config.HourlyServiceRate, DefaultRS.Next()));
Generator.OnGenerate += Queue.Enqueue;
Generator.OnGenerate += Server.RequestToStart;
Server.OnStart += Queue.Dequeue;
}
//internal TLoad Load { get; set; }
//internal int ProcedureIndex { get; set; }
public override void Invoke()
{
var load = (TLoad)(object)This.TotalNLoads++;
var pIdx = DefaultRS.Next(Config.Procedures.Count);
This.AllLoads.Add(load);
This.LoadProcedureStepIndex[load] = new Tuple <int, int>(pIdx, -1);
Execute(new AtmptMoveEvent
{
Load = load,
ProcedureIndex = pIdx,
StepIndex = 0,
});
Schedule(new ArriveEvent(), Exponential.Sample(DefaultRS, TimeSpan.FromMinutes(10)));
}
/// <param name="arrRate">Hour arrival rate to the system</param>
/// <param name="svcRate1">Hourly service rate of Server 1</param>
/// <param name="svcRate2">Hourly service rate of Server 2</param>
/// <param name="bufferQSize">Buffer queue (Queue 2) capacity</param>
public TandemQueue(double arrRate, double svcRate1, double svcRate2, int bufferQSize, int seed = 0)
: base(seed)
{
HourlyArrivalRate = arrRate;
HourlyServiceRate1 = svcRate1;
HourlyServiceRate2 = svcRate2;
Generator = AddChild(new Generator(new Generator.Statics
{
InterArrivalTime = rs => Exponential.Sample(rs, TimeSpan.FromHours(1 / HourlyArrivalRate))
}, DefaultRS.Next()));
Queue1 = AddChild(new Queue(double.PositiveInfinity, DefaultRS.Next(), id: "Queue1"));
Server1 = AddChild(new Server(new Server.Statics
{
Capacity = 1,
ServiceTime = (rs, load) => Exponential.Sample(rs, TimeSpan.FromHours(1 / HourlyServiceRate1)),
}, DefaultRS.Next(), id: "Server1"));
Queue2 = AddChild(new Queue(bufferQSize, DefaultRS.Next(), id: "Queue2"));
Server2 = AddChild(new Server(new Server.Statics
{
Capacity = 1,
ServiceTime = (rs, load) => Exponential.Sample(rs, TimeSpan.FromHours(1 / HourlyServiceRate2)),
}, DefaultRS.Next(), id: "Server2"));
Generator.OnArrive += () => Queue1.RqstEnqueue(new Load());
Generator.OnArrive += Arrive;
Queue1.OnEnqueued += Server1.RqstStart;
Server1.OnStarted += Queue1.Dequeue;
Server1.OnReadyToDepart += Queue2.RqstEnqueue;
Queue2.OnEnqueued += Server1.Depart;
Queue2.OnEnqueued += Server2.RqstStart;
Server2.OnStarted += Queue2.Dequeue;
Server2.OnReadyToDepart += Server2.Depart;
Server2.OnReadyToDepart += load => Depart();
HcInSystem = AddHourCounter();
/// Initial event
Generator.Start();
}
} } // event adapter
/**********************************************************/
/* All internal events shall be private, */
/* and inherite from InternalEvent as defined above */
/**********************************************************/
//private class InitEvent : InternalEvent
//{
// public override void Invoke()
// {
// throw new NotImplementedException();
// }
//}
#endregion
#region Input Events - Getters
/***************************************************************/
/* Methods returning an InternalEvent as O2DESNet.Event, */
/* with parameters for the objects to be passed in. */
/* Note that the InternalEvent shall always carry This = this. */
/***************************************************************/
//public Event Input(TLoad load) { return new InternalEvent { This = this, Load = load }; }
#endregion
#region Output Events - Reference to Getters
/***********************************************************************/
/* List of functions that maps outgoing objects to an external event. */
/* Note that the mapping is specified only in external structure. */
/***********************************************************************/
//public List<Func<TLoad, Event>> OnOutput { get; private set; } = new List<Func<TLoad, Event>>();
#endregion
public Modular_MMnQ(Statics config, int seed, string tag = null) : base(config, seed, tag)
{
// 子模块（动态属性）的初始化
Generator = new Generator(Config.Generator, DefaultRS.Next());
Queueing = new Queueing(Config.Queueing, DefaultRS.Next());
Server = new Server(Config.Server, DefaultRS.Next());
// 连接子模块之间的输出和输入事件
Generator.OnArrive.Add(Queueing.Enqueue);
//Generator.OnArrive.Add(() => Queueing.Enqueue());
Queueing.OnDequeue.Add(Server.Start);
Server.OnStateChg.Add(() => Queueing.UpdToDequeue(Server.Vacancy > 0));
// 初始化事件
InitEvents.AddRange(Generator.InitEvents);
}
public TademQueue_Push(Statics config, int seed = 0) : base(seed)
{
Config = config;
Generator = AddChild(new Generator(Config.HourlyArrivalRate, DefaultRS.Next()));
Queue1 = AddChild(new Queue());
Server1 = AddChild(new Server(Config.Capacity, Config.HourlyServiceRate, DefaultRS.Next()));
Queue2 = AddChild(new Queue());
Server2 = AddChild(new Server(Config.Capacity, Config.HourlyServiceRate, DefaultRS.Next()));
/// Conenction for 1st Queue & Server
Generator.OnGenerate += Queue1.Enqueue;
Queue1.OnDequeue += Server1.Start;
Server1.OnChangeAccessibility += Queue1.UpdateToDequeue;
/// Connection for 2nd Queue & Server
Server1.OnFinish += Queue2.Enqueue;
Queue2.OnDequeue += Server2.Start;
Server2.OnChangeAccessibility += Queue2.UpdateToDequeue;
}
public TandemQueue_Pull(Statics config, int seed = 0) : base(seed)
{
Config = config;
Generator = AddChild(new Generator(Config.HourlyArrivalRate, DefaultRS.Next()));
Queue1 = AddChild(new Queue());
Server1 = AddChild(new Server(Config.Capacity, Config.HourlyServiceRate, DefaultRS.Next()));
Queue2 = AddChild(new Queue());
Server2 = AddChild(new Server(Config.Capacity, Config.HourlyServiceRate, DefaultRS.Next()));
/// Connect for 1st Queue & Server
Generator.OnGenerate += Queue1.Enqueue;
Generator.OnGenerate += Server1.RequestToStart;
Server1.OnStart += Queue1.Dequeue;
/// Connect for 2nd Queue & Server
Server1.OnFinish += Queue2.Enqueue;
Server1.OnFinish += Server2.RequestToStart;
Server2.OnStart += Queue2.Dequeue;
}
public Network(Statics config, int seed, string tag = null) : base(config, seed, tag)
{
Name = "Network";
Display = true;
for (int i = 0; i < Config.NNodes; i++)
{
for (int j = 0; j < Config.NNodes; j++)
{
if (i != j && Config.DemandRates[i, j] > 0)
{
int o = i, d = j;
var g = new Generator <Order>(
new Generator <Order> .Statics
{
Create = rs => new Order(new Order.Statics
{
Origin = o,
Destination = d,
}, rs.Next()),
InterArrivalTime = rs => TimeSpan.FromDays(
Exponential.Sample(rs, 1 / Config.DemandRates[o, d])),
SkipFirst = true,
}, DefaultRS.Next());
g.OnArrive.Add(order => new DemandArriveEvent {
This = this, Order = order
});
Generators.Add(new Tuple <int, int>(i, j), g);
InitEvents.Add(g.Start());
}
}
}
Transporters.AddRange(Enumerable.Range(0, Config.NTransporters)
.Select(i => new Transporter(new Transporter.Statics(), DefaultRS.Next())
{
Display = Display,
Tag = "Transporter#" + i,
}));
foreach (var t in Transporters)
{
t.OnFinishTransport.Add(order => new DeliverEvent {
This = this, Order = order
});
}
InitEvents.AddRange(Transporters.Select(t => t.Init(this)));
}
public ConstrainedTandemQueue_Pull(Statics config, int seed = 0) : base(seed)
{
Config = config;
Generator = AddChild(new Generator(Config.HourlyArrivalRate, DefaultRS.Next()));
Queue1 = AddChild(new Queue(Config.QueueCapacity));
Server1 = AddChild(new Server(Config.ServerCapacity, Config.HourlyServiceRate, DefaultRS.Next()));
Queue2 = AddChild(new Queue(Config.QueueCapacity));
Server2 = AddChild(new Server(Config.ServerCapacity, Config.HourlyServiceRate, DefaultRS.Next()));
/// Connect for 1st Queue & Server
Generator.OnGenerate += Queue1.RequestToEnqueue;
Generator.OnGenerate += Server1.RequestToStart;
Server1.OnStart += Queue1.Dequeue;
/// Connect for 2nd Queue & Server
Server1.OnReadyToFinish += Queue2.RequestToEnqueue;
Server1.OnReadyToFinish += Server2.RequestToStart;
Queue2.OnEnqueue += Server1.Finish;
Server2.OnStart += Queue2.Dequeue;
/// Enclose 2nd Server
Server2.OnReadyToFinish += Server2.Finish;
}
/***************************************************************/
/* Methods returning an InternalEvent as O2DESNet.Event, */
/* with parameters for the objects to be passed in. */
/* Note that the InternalEvent shall always carry This = this. */
/***************************************************************/
//public Event Input(TLoad load) { return new InternalEvent { This = this, Load = load }; }
#endregion
#region Output Events - Reference to Getters
/***********************************************************************/
/* List of functions that maps outgoing objects to an external event. */
/* Note that the mapping is specified only in external structure. */
/***********************************************************************/
//public List<Func<TLoad, Event>> OnOutput { get; private set; } = new List<Func<TLoad, Event>>();
#endregion
public MultiServers(Statics config, int seed, string tag = null) : base(config, seed, tag)
{
int nTypes = Config.HourlyArrivalRates.Length;
int nServers = Config.HourlyServiceRates.GetLength(0);
// 根据每一种类型客户的到达率创建随即发生器
Generators = Enumerable.Range(0, nTypes)
.Select(type => new Generator <Customer>(
new Generator <Customer> .Statics {
Create = rs => new Customer(type),
InterArrivalTime = rs => TimeSpan.FromHours(
Exponential.Sample(rs, Config.HourlyArrivalRates[type])),
SkipFirst = true
}, DefaultRS.Next())).ToArray();
// 创建服务器，并根据不同类型的客户设置服务事件
Servers = Enumerable.Range(0, nServers)
.Select(i => new Server <Customer>(
new Server <Customer> .Statics {
Capacity = Config.Capacities[i],
ServiceTime = (cstm, rs) => TimeSpan.FromHours(
Exponential.Sample(rs, Config.HourlyServiceRates[i, cstm.Config.Type])),
}, DefaultRS.Next())).ToArray();
// 将发生器输出事件连接至内部事件
foreach (var g in Generators)
{
g.OnArrive.Add(c => new ArriveEvent {
This = this, Customer = c
});
}
// 将服务器输出事件连接至内部事件
foreach (var s in Servers)
{
s.OnDepart.Add(c => new DepartEvent {
This = this, Customer = c
});
}
// 初始化事件
InitEvents.AddRange(Generators.Select(g => g.Start()));
}
public RCQsContext(Statics config, int seed = 0) : base(seed)
{
Config = config;
_rcqModel = AddChild(new RCQsModel(new RCQsModel.Statics(Config.Resources), DefaultRS.Next()));
_rcqModel.OnStarted += Start;
_rcqModel.OnReadyToExit += _rcqModel.Exit;
}
public MMcQueue_Push(Statics config, int seed = 0) : base(seed)
{
Config = config;
Generator = AddChild(new Generator(Config.HourlyArrivalRate, DefaultRS.Next()));
Queue = AddChild(new Queue());
Server = AddChild(new Server(Config.Capacity, Config.HourlyServiceRate, DefaultRS.Next()));
Generator.OnGenerate += Queue.Enqueue;
Queue.OnDequeue += Server.Start;
Server.OnChangeAccessibility += Queue.UpdateToDequeue;
}
public override void Invoke()
{
This.Network = Network;
This.CurrentNode = DefaultRS.Next(Network.Config.NNodes);
}
