Implement enabling/disabling of monitors

Author: abeham

Samples/KanbanControl.cs

@@ -53,9 +53,9 @@ private IEnumerable<Event> Produce(Request kb) {
       }
     }
 
-    public void Simulate() {
+    public void Simulate(int rseed = 42) {
       completedOrders = 0;
-      env = new Simulation();
+      env = new Simulation(randomSeed: rseed);
       env.Log("== Kanban controlled production system ==");
       kanban = new Resource(env, capacity: 15);
       server = new Resource(env, capacity: 1);
@@ -67,7 +67,7 @@ public void Simulate() {
       env.Run(TimeSpan.FromDays(180));
       Console.WriteLine("Kanbans in stock: {0} ; {1:F1}±{2:F1} ; {3} (Min;Mean±StdDev;Max) kanbans ", stockStat.Min, stockStat.Mean, stockStat.StdDev, stockStat.Max);
       Console.WriteLine("Produced kanbans: {0:N0}", completedOrders);
-      Console.WriteLine(stockStat.Summarize(histInterval: 1));
+      Console.WriteLine(stockStat.Summarize(binWidth: 1));
     }
   }
 }

Samples/MM1Queueing.cs

@@ -38,23 +38,30 @@ private IEnumerable<Event> Order(Simulation env, Resource server) {
       }
     }
 
-    public void Simulate() {
-      var lambda = 1 / OrderArrivalTime.TotalMinutes;
-      var mu = 1 / ProcessingTime.TotalMinutes;
+    private IEnumerable<Event> HandleWarmup(Simulation env, TimeSpan warmupTime, params IMonitor[] monitors) {
+      foreach (var mon in monitors) mon.Active = false;
+      yield return env.Timeout(warmupTime);
+      foreach (var mon in monitors) mon.Active = true;
+    }
+
+    public void Simulate(int repetitions = 5) {
+      var lambda = 1 / OrderArrivalTime.TotalDays;
+      var mu = 1 / ProcessingTime.TotalDays;
       var rho = lambda / mu;
       var analyticWIP = rho / (1 - rho);
       var analyticLeadtime = 1 / (mu - lambda);
       var analyticWaitingtime = rho / (mu - lambda);
 
-      var env = new Simulation(randomSeed: 1, defaultStep: TimeSpan.FromMinutes(1));
+      var env = new Simulation(randomSeed: 1, defaultStep: TimeSpan.FromDays(1));
       var utilization = new TimeSeriesMonitor(env, name: "Utilization");
       var wip = new TimeSeriesMonitor(env, name: "WIP", collect: true);
       var leadtime = new SampleMonitor(name: "Lead time", collect: true);
       var waitingtime = new SampleMonitor(name: "Waiting time", collect: true);
 
       env.Log("Analytical results of this system:");
-      env.Log("\tUtilization.Mean\tWIP.Mean\tLeadtime.Mean\tWaitingTime.Mean");
-      env.Log("\t{0}\t{1}\t{2}\t{3}", rho, analyticWIP, analyticLeadtime, analyticWaitingtime);
+      env.Log("Time\tUtilization.Mean\tWIP.Mean\tLeadtime.Mean\tWaitingTime.Mean");
+      env.Log("{4}\t{0}\t{1}\t{2}\t{3}", rho, analyticWIP, analyticLeadtime, analyticWaitingtime, double.PositiveInfinity);
+      env.Log("");
 
       // example to create a running report of these measures every simulated week
       //var report = Report.CreateBuilder(env)
@@ -78,11 +85,11 @@ public void Simulate() {
         .SetTimeAPI(useDApi: true)
         .Build();
 
-      env.Log("Simulated results of this system:");
+      env.Log("Simulated results of this system (" + repetitions + " repetitions):");
       env.Log("");
       summary.WriteHeader(); // write the header just once
 
-      for (var i = 0; i < 5; i++) {
+      for (var i = 0; i < repetitions; i++) {
         env.Reset(i + 1); // reset environment
         utilization.Reset(); // reset monitors
         wip.Reset();
@@ -96,16 +103,17 @@ public void Simulate() {
         };
 
         env.Process(Source(env, server));
+        env.Process(HandleWarmup(env, TimeSpan.FromDays(32), utilization, wip, leadtime, waitingtime));
         env.Run(TimeSpan.FromDays(365));
       }
 
       env.Log("");
       env.Log("Detailed results from the last run:");
       env.Log("");
       env.Log(utilization.Summarize());
-      env.Log(wip.Summarize(maxBins: 10, histInterval: 2));
-      env.Log(leadtime.Summarize(maxBins: 10, histInterval: 5));
-      env.Log(waitingtime.Summarize(maxBins: 10, histInterval: 4));  ;
+      env.Log(wip.Summarize(maxBins: 10, binWidth: 2));
+      env.Log(leadtime.Summarize(maxBins: 10, binWidth: 5 / 1440.0));
+      env.Log(waitingtime.Summarize(maxBins: 10, binWidth: 4 / 1440.0));  ;
     }
   }
 }

SimSharp/Analysis/IMonitor.cs

@@ -20,6 +20,16 @@ You should have received a copy of the GNU General Public License
 
 namespace SimSharp {
   public interface IMonitor {
+    bool Active { get; set; }
+    string Name { get; }
+
+    string Summarize();
+
+
+    event EventHandler Updated;
+  }
+
+  public interface INumericMonitor : IMonitor {
     bool Collect { get; }
 
     double Min { get; }
@@ -31,17 +41,13 @@ public interface IMonitor {
 
     double GetMedian();
     double GetPercentile(double p);
-
-    string Summarize();
-    
-    event EventHandler Updated;
   }
 
-  public interface ISampleMonitor : IMonitor {
+  public interface ISampleMonitor : INumericMonitor {
     void Add(double value);
   }
 
-  public interface ITimeSeriesMonitor : IMonitor {
+  public interface ITimeSeriesMonitor : INumericMonitor {
     void Increase(double value);
     void Decrease(double value);
     void UpdateTo(double value);

SimSharp/Analysis/Report.cs

@@ -237,7 +237,7 @@ public Builder(Simulation env) {
       /// or when <paramref name="measure"/> is not valid.</exception>
       /// <exception cref="ArgumentNullException">Thrown when <paramref name="statistics"/> is null.</exception>
       /// <returns>This builder instance.</returns>
-      public Builder Add(string name, IMonitor statistics, Measures measure = Measures.All) {
+      public Builder Add(string name, INumericMonitor statistics, Measures measure = Measures.All) {
         if (string.IsNullOrEmpty(name)) throw new ArgumentException("Name must be a non-empty string", "name");
         if (statistics == null) throw new ArgumentNullException("statistics");
         if (measure == 0 || measure > Measures.All) throw new ArgumentException("No measures have been selected.", "measure");
@@ -383,7 +383,7 @@ private static int CountSetBits(int num) {
 
     private class Key {
       public string Name { get; set; }
-      public IMonitor Statistics { get; set; }
+      public INumericMonitor Statistics { get; set; }
       public Measures Measure { get; set; }
       public int TotalMeasures { get; set; }
     }

SimSharp/Analysis/SampleMonitor.cs

@@ -37,6 +37,13 @@ public sealed class SampleMonitor : ISampleMonitor {
     /// </summary>
     public bool Collect { get; }
 
+    /// <summary>
+    /// The monitor can be set to suppress updates. When it is set
+    /// to false, the statistics will not be updated and new samples
+    /// are ignored.
+    /// </summary>
+    public bool Active { get; set; }
+
     /// <summary>
     /// The name of the variable that is being monitored.
     /// Used for output in <see cref="Summarize(bool, int, double?, double?)"/>.
@@ -48,7 +55,7 @@ public sealed class SampleMonitor : ISampleMonitor {
     public double Min { get; private set; }
     public double Max { get; private set; }
     public double Total { get; private set; }
-    double IMonitor.Sum { get { return Total; } }
+    double INumericMonitor.Sum { get { return Total; } }
     public double Mean { get; private set; }
     public double StdDev { get { return Math.Sqrt(Variance); } }
     public double Variance { get { return (Count > 0) ? variance / Count : 0.0; } }
@@ -104,6 +111,7 @@ private static double GetPercentile(IList<double> s, double p) {
     }
 
     public SampleMonitor(string name = null, bool collect = false) {
+      Active = true;
       Name = name;
       Collect = collect;
       if (collect) samples = new List<double>(64);
@@ -118,6 +126,8 @@ public void Reset() {
     }
 
     public void Add(double value) {
+      if (!Active) return;
+
       if (double.IsNaN(value) || double.IsInfinity(value))
         throw new ArgumentException("Not a valid double", "value");
       Count++;
@@ -157,7 +167,7 @@ string IMonitor.Summarize() {
     /// the data to produce the histogram is not available in the first place.</param>
     /// <param name="maxBins">The maximum number of bins that should be used.
     /// Note that the bin width and thus the number of bins is also governed by
-    /// <paramref name="histInterval"/> if it is defined.
+    /// <paramref name="binWidth"/> if it is defined.
     /// This is only effective if <see cref="Collect"/> and <paramref name="withHistogram"/>
     /// was set to true, otherwise the data to produce the histogram is not available
     /// in the first place.</param>
@@ -166,14 +176,14 @@ string IMonitor.Summarize() {
     /// This is only effective if <see cref="Collect"/> and <paramref name="withHistogram"/>
     /// was set to true, otherwise the data to produce the histogram is not available
     /// in the first place.</param>
-    /// <param name="histInterval">The interval for the bins of the histogram or the
+    /// <param name="binWidth">The interval for the bins of the histogram or the
     /// range (<see cref="Max"/> - <see cref="Min"/>) divided by the number of bins
     /// (<paramref name="maxBins"/>) in case the default value (null) is given.
     /// This is only effective if <see cref="Collect"/> and <paramref name="withHistogram"/>
     /// was set to true, otherwise the data to produce the histogram is not available
     /// in the first place.</param>
     /// <returns>A formatted string that provides a summary of the statistics.</returns>
-    public string Summarize(bool withHistogram = true, int maxBins = 20, double? histMin = null, double? histInterval = null) {
+    public string Summarize(bool withHistogram = true, int maxBins = 20, double? histMin = null, double? binWidth = null) {
       var nozero = Collect ? samples.Where(x => x != 0).ToList() : new List<double>();
       var nozeromin = nozero.Count > 0 ? nozero.Min() : double.NaN;
       var nozeromax = nozero.Count > 0 ? nozero.Max() : double.NaN;
@@ -200,7 +210,7 @@ public string Summarize(bool withHistogram = true, int maxBins = 20, double? his
 
       if (Collect && withHistogram) {
         var min = histMin ?? Min;
-        var interval = histInterval ?? (Max - Min) / maxBins;
+        var interval = binWidth ?? (Max - Min) / maxBins;
         var histData = samples.GroupBy(x => x <= min ? 0 : (int)Math.Floor(Math.Min((x - min + interval) / interval, maxBins)))
                            .Select(x => new { Key = x.Key, Value = x.Count() })
                            .OrderBy(x => x.Key);