public async Task RunAkkaSimulation(Configuration configuration)
{
_configuration = configuration;
_messageHub.SendToAllClients(msg: "Prepare in Memory model from DB for Simulation: "
+ _configuration.GetOption <SimulationId>().Value);
_messageHub.SendToAllClients(msg: "Prepare Simulation");
_agentSimulation = new AgentSimulation(DBContext: _context
, messageHub: _messageHub); // Defines the status output
var simulation = await _agentSimulation.InitializeSimulation(configuration : _configuration);
SimulationContext = simulation.SimulationContext;
if (simulation.IsReady())
{
_messageHub.StartSimulation(simId: _configuration.GetOption <SimulationId>().Value.ToString()
, simNumber: _configuration.GetOption <SimulationNumber>().Value.ToString());
// Start simulation
var sim = simulation.RunAsync();
_agentSimulation.StateManager.ContinueExecution(simulation);
await sim;
}
_messageHub.EndSimulation(msg: "Simulation Completed."
, simId: _configuration.GetOption <SimulationId>().Value.ToString()
, simNumber: _configuration.GetOption <SimulationNumber>().Value.ToString());
return;
}
public async Task BenchmarksOrderArrival()
{
//InMemoryContext.LoadData(source: _masterDBContext, target: _ctx);
var simContext = new AgentSimulation(DBContext: _masterDBContext, messageHub: new ConsoleHub());
var simConfig = SimulationCore.Environment.Configuration.Create(args: new object[]
{
// set ResultDBString and set SaveToDB true
new DBConnectionString(value: localresultdb), new SimulationId(value: 1), new SimulationNumber(value: simNr++),
new SimulationKind(value: SimulationType) // implements the used behaviour, if None --> DefaultBehaviour
,
new OrderArrivalRate(value: OrderArrivalRate), new OrderQuantity(value: Int32.MaxValue),
new TransitionFactor(value: 3), new EstimatedThroughPut(value: 1920), new DebugAgents(value: false),
new DebugSystem(value: false), new KpiTimeSpan(value: 480), new MaxBucketSize(value: MaxBucketSize),
new Seed(value: 1337), new MinDeliveryTime(value: 1440), new MaxDeliveryTime(value: 2880),
new TimePeriodForThroughputCalculation(value: 3840), new SettlingStart(value: 4320),
new SimulationEnd(value: 20160), new WorkTimeDeviation(value: 0.2), new SaveToDB(value: false)
});
var simulation = await simContext.InitializeSimulation(configuration : simConfig);
// emtpyResultDBbySimulationNumber(simNr: simConfig.GetOption<SimulationNumber>());
if (simulation.IsReady())
{
// Start simulation
var sim = simulation.RunAsync();
simContext.StateManager.ContinueExecution(simulation);
sim.Wait();
}
}
public async Task AgentSimulatioAsync(int simulationConfigurationId)
{
// In-memory database only exists while the connection is open
var connectionStringBuilder = new SqliteConnectionStringBuilder {
DataSource = ":memory:"
};
var connection = new SqliteConnection(connectionStringBuilder.ToString());
// create OptionsBuilder with InMemmory Context
var builder = new DbContextOptionsBuilder <MasterDBContext>();
builder.UseSqlite(connection);
var simNumber = _evaluationContext.GetSimulationNumber(simulationConfigurationId, SimulationType.Decentral);
using (var c = new InMemoryContext(builder.Options))
{
c.Database.OpenConnection();
c.Database.EnsureCreated();
InMemoryContext.LoadData(_evaluationContext, c);
var sim = new AgentSimulation(c, _messageHub);
await sim.RunSim(simulationConfigurationId, simNumber);
CopyResults.Copy(c, _evaluationContext, simulationConfigurationId, simNumber, SimulationType.Decentral);
CalculateKpis.MachineSattleTime(_evaluationContext, simulationConfigurationId, SimulationType.Decentral, simNumber);
CalculateKpis.CalculateAllKpis(_evaluationContext, simulationConfigurationId, SimulationType.Decentral, simNumber, true);
}
connection.Close();
_messageHub.EndSimulation("Simulation with Id:" + simulationConfigurationId + " Completed."
, simulationConfigurationId.ToString()
, simNumber.ToString());
}
public async Task SystemTestAsync()
{
//InMemoryContext.LoadData(source: _masterDBContext, target: _ctx);
var simContext = new AgentSimulation(DBContext: _masterDBContext, messageHub: new ConsoleHub());
var simConfig = SimulationCore.Environment.Configuration.Create(args: new object[]
{
// set ResultDBString and set SaveToDB true
new DBConnectionString(value: localresultdb)
, new SimulationId(value: 1)
, new SimulationNumber(value: simNr)
, new SimulationKind(value: SimulationType.None) // implements the used behaviour, if None --> DefaultBehaviour
, new OrderArrivalRate(value: 0.025)
, new OrderQuantity(value: 1)
, new TransitionFactor(value: 3)
, new EstimatedThroughPut(value: 600)
, new DebugAgents(value: true)
, new DebugSystem(value: false)
, new KpiTimeSpan(value: 480)
, new Seed(value: 1337)
, new MinDeliveryTime(value: 1160)
, new MaxDeliveryTime(value: 1600)
, new TimePeriodForThrougputCalculation(value: 3840)
, new SettlingStart(value: 2880)
, new SimulationEnd(value: 20160)
, new WorkTimeDeviation(value: 0.2)
, new SaveToDB(value: false)
});
var simulation = await simContext.InitializeSimulation(configuration : simConfig);
emtpyResultDBbySimulationNumber(simNr: simConfig.GetOption <SimulationNumber>());
var simWasReady = false;
if (simulation.IsReady())
{
// set for Assert
simWasReady = true;
// Start simulation
var sim = simulation.RunAsync();
AgentSimulation.Continuation(inbox: simContext.SimulationConfig.Inbox
, sim: simulation
, collectors: new List <IActorRef> {
simContext.StorageCollector
, simContext.WorkCollector
, simContext.ContractCollector
});
await sim;
}
Assert.True(condition: simWasReady);
}
public async Task RunAkkaSimulation(Configuration configuration)
{
_configuration = configuration;
_messageHub.SendToAllClients(msg: "Prepare in Memory model from DB for Simulation: "
+ _configuration.GetOption <SimulationId>().Value.ToString()
, msgType: MessageType.info);
//In-memory database only exists while the connection is open
//var _inMemory = InMemoryContext.CreateInMemoryContext();
// InMemoryContext.LoadData(source: _context, target: _inMemory);
//MasterDBInitializerSimple.DbInitialize(_inMemory);
_messageHub.SendToAllClients(msg: "Prepare Simulation", msgType: MessageType.info);
_agentSimulation = new AgentSimulation(DBContext: _context
, messageHub: _messageHub); // Defines the status output
var simulation = _agentSimulation.InitializeSimulation(configuration: _configuration).Result;
SimulationContext = simulation.SimulationContext;
if (simulation.IsReady())
{
_messageHub.SendToAllClients(msg: "Start Simulation ...", msgType: MessageType.info);
// Start simulation
var sim = simulation.RunAsync();
AgentSimulation.Continuation(inbox: _agentSimulation.SimulationConfig.Inbox
, sim: simulation
, collectors: new List <IActorRef> {
_agentSimulation.StorageCollector
, _agentSimulation.WorkCollector
, _agentSimulation.ContractCollector
});
await sim;
}
_messageHub.EndScheduler();
_messageHub.EndSimulation(msg: "Simulation Completed."
, simId: _configuration.GetOption <SimulationId>().Value.ToString()
, simNumber: _configuration.GetOption <SimulationNumber>().Value.ToString());
return;
}
public void RunProduction(int uniqueSimNum, int orderQuantity, ModelSize resourceModelSize,
ModelSize setupModelSize, ModelSize operatorModelSize, int numberOfWorkers, bool secondResource)
{
LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Info, LogLevel.Info);
LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Debug, LogLevel.Debug);
_testOutputHelper.WriteLine("DatabaseString: " + _contextDataBase.ConnectionString.Value);
_testOutputHelper.WriteLine("ResultDatabaseString: " + _resultContextDataBase.ConnectionString.Value);
//Handle this one in our Resource Model?
MasterDBInitializerTruck.DbInitialize(_contextDataBase.DbContext, resourceModelSize, setupModelSize,
operatorModelSize, numberOfWorkers, secondResource);
_testOutputHelper.WriteLine("MasterDBInitialized finished");
ResultDBInitializerBasic.DbInitialize(_resultContextDataBase.DbContext);
_testOutputHelper.WriteLine("ResultDBInitializerBasic finished");
var messageHub = new ConsoleHub();
var simContext = new AgentSimulation(DBContext: _contextDataBase.DbContext, messageHub: messageHub);
var simConfig = ArgumentConverter.ConfigurationConverter(_resultContextDataBase.DbContext, 1);
_testOutputHelper.WriteLine("ArgumentConverter finished");
simConfig.ReplaceOption(new DBConnectionString(_resultContextDataBase.ConnectionString.Value));
simConfig.ReplaceOption(new TimeToAdvance(new TimeSpan(0L)));
simConfig.ReplaceOption(new KpiTimeSpan(240));
simConfig.ReplaceOption(new DebugAgents(true));
simConfig.ReplaceOption(new MinDeliveryTime(1440));
simConfig.ReplaceOption(new MaxDeliveryTime(2880));
simConfig.ReplaceOption(new TransitionFactor(3));
simConfig.ReplaceOption(new SimulationKind(value: SimulationType.Default));
simConfig.ReplaceOption(new OrderArrivalRate(value: 0.15));
simConfig.ReplaceOption(new OrderQuantity(value: orderQuantity));
simConfig.ReplaceOption(new EstimatedThroughPut(value: 1920));
simConfig.ReplaceOption(new TimePeriodForThroughputCalculation(value: 2880));
simConfig.ReplaceOption(new Seed(value: 1337));
simConfig.ReplaceOption(new SettlingStart(value: 0));
simConfig.ReplaceOption(new SimulationEnd(value: 4380));
simConfig.ReplaceOption(new SaveToDB(value: true));
simConfig.ReplaceOption(new MaxBucketSize(value: 480));
simConfig.ReplaceOption(new SimulationNumber(value: uniqueSimNum));
simConfig.ReplaceOption(new DebugSystem(value: true));
simConfig.ReplaceOption(new WorkTimeDeviation(0.0));
simConfig.ReplaceOption(new TimeConstraintQueueLength(480));
var simulation = simContext.InitializeSimulation(configuration: simConfig).Result;
_testOutputHelper.WriteLine("simContext.InitializeSimulation finished");
var sim = simulation.RunAsync();
_testOutputHelper.WriteLine("simulation.RunAsync() finished");
Within(TimeSpan.FromSeconds(120), async() =>
{
simContext.StateManager.ContinueExecution(simulation);
await sim;
}).Wait();
var processedOrders =
_resultContextDataBase.DbContext.Kpis
.Single(x => x.IsFinal.Equals(true) && x.Name.Equals("OrderProcessed")).Value;
Assert.Equal(orderQuantity, processedOrders);
Assert.False(AnyOverlappingTaskItemsExistsOnOneMachine());
foreach (var obj in messageHub.Logs)
{
dynamic guardChildCounter = JsonConvert.DeserializeObject(obj);
Assert.Equal(0, int.Parse(guardChildCounter[1].Value));
}
_contextDataBase.DbContext.Dispose();
_resultContextDataBase.DbContext.Dispose();
}
public async Task SystemTestAsync(int approachId
, int orderQuantity
, int maxBucketSize
, long throughput
, int seed
, double arrivalRate
, long simulationEnd)
{
ResultContext ctxResult = ResultContext.GetContext(resultCon: testResultCtxString);
ProductionDomainContext masterCtx = ProductionDomainContext.GetContext(testCtxString);
DataGeneratorContext dataGenCtx = DataGeneratorContext.GetContext(testGeneratorCtxString);
var approach = ApproachRepository.GetApproachById(dataGenCtx, approachId);
var generator = new MainGenerator();
await Task.Run(() =>
generator.StartGeneration(approach, masterCtx, ctxResult));
var simContext = new AgentSimulation(DBContext: masterCtx, messageHub: new ConsoleHub());
var simConfig = ArgumentConverter.ConfigurationConverter(ctxResult, 1);
//LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Trace, LogLevel.Trace);
LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Info, LogLevel.Info);
//LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Debug, LogLevel.Debug);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.PRIORITY, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, CustomLogger.SCHEDULING, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, CustomLogger.DISPOPRODRELATION, LogLevel.Debug, LogLevel.Debug);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.PROPOSAL, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.INITIALIZE, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.JOB, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, CustomLogger.ENQUEUE, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.JOBSTATE, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, TargetNames.LOG_AKKA, LogLevel.Trace, LogLevel.Trace);
//LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AKKA, LogLevel.Warn);
var dataGenSim = new DB.GeneratorModel.Simulation();
dataGenSim.ApproachId = approachId;
dataGenSim.StartTime = DateTime.Now;
await Task.Run(() =>
{
dataGenCtx.Simulations.AddRange(dataGenSim);
dataGenCtx.SaveChanges();
});
// update customized Configuration
simConfig.AddOption(new DBConnectionString(testResultCtxString));
simConfig.ReplaceOption(new TimeConstraintQueueLength(480));
simConfig.ReplaceOption(new OrderArrivalRate(value: arrivalRate));
simConfig.ReplaceOption(new OrderQuantity(value: orderQuantity));
simConfig.ReplaceOption(new EstimatedThroughPut(value: throughput));
simConfig.ReplaceOption(new TimePeriodForThroughputCalculation(value: 2880));
simConfig.ReplaceOption(new Seed(value: seed));
simConfig.ReplaceOption(new SettlingStart(value: 0));
simConfig.ReplaceOption(new SimulationEnd(value: simulationEnd));
simConfig.ReplaceOption(new SaveToDB(value: true));
simConfig.ReplaceOption(new MaxBucketSize(value: maxBucketSize));
simConfig.ReplaceOption(new SimulationNumber(value: dataGenSim.Id));
simConfig.ReplaceOption(new DebugSystem(value: true));
simConfig.ReplaceOption(new WorkTimeDeviation(0.0));
// anpassen der Lieferzeiten anhand der Erwarteten Durchlaufzeit.
simConfig.ReplaceOption(new MinDeliveryTime(80));
simConfig.ReplaceOption(new MaxDeliveryTime(150));
await Task.Run(() =>
ArgumentConverter.ConvertBackAndSave(ctxResult, simConfig, dataGenSim.Id));
var simulation = await simContext.InitializeSimulation(configuration : simConfig);
if (simulation.IsReady())
{
// Start simulation
var sim = simulation.RunAsync();
simContext.StateManager.ContinueExecution(simulation);
await sim;
dataGenSim.FinishTime = DateTime.Now;
dataGenSim.FinishedSuccessfully = sim.IsCompletedSuccessfully;
await Task.Run(() =>
dataGenCtx.SaveChanges());
System.Diagnostics.Debug.WriteLine("################################# Simulation has finished with number " + dataGenSim.Id);
Assert.True(condition: sim.IsCompleted);
}
}
public AgentSimulator(ProductionDomainContext context, IMessageHub messageHub)
{
_context = context;
_agentSimulation = new AgentSimulation(context, messageHub);
_messageHub = messageHub;
}
public async Task SystemTestAsync(SimulationType simulationType, int simNr, int maxBucketSize, long throughput,
int seed
, ModelSize resourceModelSize, ModelSize setupModelSize
, double arrivalRate, bool distributeSetupsExponentially)
{
LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Trace, LogLevel.Trace);
LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Info, LogLevel.Info);
LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Debug, LogLevel.Debug);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.PRIORITY, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, CustomLogger.SCHEDULING, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, CustomLogger.DISPOPRODRELATION, LogLevel.Debug, LogLevel.Debug);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.PROPOSAL, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.INITIALIZE, LogLevel.Warn, LogLevel.Warn);
LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.JOB, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, CustomLogger.ENQUEUE, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.JOBSTATE, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, TargetNames.LOG_AKKA, LogLevel.Trace, LogLevel.Trace);
//LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AKKA, LogLevel.Warn);
var masterCtx = ProductionDomainContext.GetContext(testCtxString);
masterCtx.Database.EnsureDeleted();
masterCtx.Database.EnsureCreated();
MasterDBInitializerTruck.DbInitialize(masterCtx, resourceModelSize, setupModelSize, ModelSize.Small, 3, distributeSetupsExponentially);
//InMemoryContext.LoadData(source: _masterDBContext, target: _ctx);
var simContext = new AgentSimulation(DBContext: masterCtx, messageHub: new ConsoleHub());
var simConfig = Simulation.CLI.ArgumentConverter.ConfigurationConverter(_ctxResult, 1);
// update customized Items
simConfig.AddOption(new DBConnectionString(testResultCtxString));
simConfig.ReplaceOption(new TimeConstraintQueueLength(480));
simConfig.ReplaceOption(new SimulationKind(value: simulationType));
simConfig.ReplaceOption(new OrderArrivalRate(value: arrivalRate));
simConfig.ReplaceOption(new OrderQuantity(value: 5));
simConfig.ReplaceOption(new EstimatedThroughPut(value: throughput));
simConfig.ReplaceOption(new TimePeriodForThroughputCalculation(value: 2880));
simConfig.ReplaceOption(new Seed(value: seed));
simConfig.ReplaceOption(new SettlingStart(value: 0));
simConfig.ReplaceOption(new SimulationEnd(value: 2880));
simConfig.ReplaceOption(new SaveToDB(value: true));
simConfig.ReplaceOption(new MaxBucketSize(value: maxBucketSize));
simConfig.ReplaceOption(new SimulationNumber(value: simNr));
simConfig.ReplaceOption(new DebugSystem(value: true));
simConfig.ReplaceOption(new WorkTimeDeviation(0.0));
var simulation = await simContext.InitializeSimulation(configuration : simConfig);
emtpyResultDBbySimulationNumber(simNr: simConfig.GetOption <SimulationNumber>());
var simWasReady = false;
if (simulation.IsReady())
{
// set for Assert
simWasReady = true;
// Start simulation
var sim = simulation.RunAsync();
simContext.StateManager.ContinueExecution(simulation);
await sim;
}
Assert.True(condition: simWasReady);
}
