public ActionResult Index(int length, int alphabetCardinality, int typeGenerate)
{
return(CreateTask(() =>
{
ISequenceGenerator sequenceGenerator = null;
var orderGenerator = new OrderGenerator();
var orders = new List <int[]>();
switch (typeGenerate)
{
case 0:
sequenceGenerator = new StrictSequenceGenerator();
orders = orderGenerator.StrictGenerateOrders(length, alphabetCardinality);
break;
case 1:
sequenceGenerator = new SequenceGenerator();
orders = orderGenerator.GenerateOrders(length, alphabetCardinality);
break;
case 2:
sequenceGenerator = new NonRedundantStrictSequenceGenerator();
orders = orderGenerator.StrictGenerateOrders(length, alphabetCardinality);
break;
case 3:
sequenceGenerator = new NonRedundantSequenceGenerator();
orders = orderGenerator.GenerateOrders(length, alphabetCardinality);
break;
default: throw new ArgumentException("Invalid type of generate");
}
var sequences = sequenceGenerator.GenerateSequences(length, alphabetCardinality);
var SequecesOrdersDistribution = new Dictionary <int[], List <BaseChain> >(new OrderEqualityComparer());
foreach (var order in orders)
{
SequecesOrdersDistribution.Add(order, new List <BaseChain>());
}
foreach (var sequence in sequences)
{
SequecesOrdersDistribution[sequence.Building].Add(sequence);
}
var result = new Dictionary <string, object>
{
{
"result", SequecesOrdersDistribution.Select(r => new
{
order = r.Key,
sequences = r.Value.Select(s => s.ToString(",")).ToArray()
})
}
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public void CalculateTransformations(int length)
{
var orderGenerator = new OrderGenerator();
Orders = orderGenerator.GenerateOrders(length);
TransformationsData = new OrderTransformationData[Orders.Count];
TransformOrders();
}
/// <summary>
/// Call this method for a single run without simulation.
/// </summary>
/// <param name="task"></param>
/// <param name="simulationId"></param>
/// <returns></returns>
public async Task InitializeMrp(MrpTask task, int simulationId)
{
await Task.Run(async() =>
{
_messageHub.SendToAllClients("Prepare InMemory Tables...", MessageType.info);
rebuildNets = new RebuildNets(_context);
capacityScheduling = new CapacityScheduling(_context);
_context = InMemoryContext.CreateInMemoryContext();
InMemoryContext.LoadData(_evaluationContext, _context);
await PrepareSimulationContext();
var simConfig = _context.SimulationConfigurations.Single(x => x.Id == simulationId);
await OrderGenerator.GenerateOrders(_context, simConfig, simulationId);
var simulationNumber = _context.GetSimulationNumber(simulationId, SimulationType.Central);
//call initial central MRP-run
await _processMrp.CreateAndProcessOrderDemand(task, _context, simulationId, _evaluationContext);
if (task == MrpTask.Backward || task == MrpTask.Forward || task == MrpTask.GifflerThompson)
{
var list = _context.ProductionOrderWorkSchedules.Select(schedule => new PowsSimulationItem(_context)
{
End = (task == MrpTask.Backward) ? schedule.EndBackward : (task == MrpTask.Forward) ? schedule.EndForward : schedule.End,
Start = (task == MrpTask.Backward) ? schedule.StartBackward : (task == MrpTask.Forward) ? schedule.StartForward : schedule.Start,
ProductionOrderId = schedule.ProductionOrderId,
ProductionOrderWorkScheduleId = schedule.Id,
SimulationId = simulationId
})
.ToList();
_evaluationContext.SaveChanges();
FillSimulationWorkSchedules(list, simulationId, simulationNumber, task);
}
SimulationType simType = SimulationType.Central;
switch (task)
{
case MrpTask.Forward:
simType = SimulationType.ForwardPlanning;
break;
case MrpTask.Backward:
simType = SimulationType.BackwardPlanning;
break;
}
CopyResults.ExtractSimulationOrders(_context, _evaluationContext, simulationId, simulationNumber, simType);
_messageHub.EndScheduler();
});
}
private async Task <TimeTable <ISimulationItem> > InitializeSimulation(int simulationId, int simNumber, SimulationConfiguration simConfig)
{
_messageHub.SendToAllClients("Start Simulation...", MessageType.info);
_context = InMemoryContext.CreateInMemoryContext();
InMemoryContext.LoadData(_evaluationContext, _context);
capacityScheduling = new CapacityScheduling(_context);
rebuildNets = new RebuildNets(_context);
await PrepareSimulationContext();
await OrderGenerator.GenerateOrders(_context, simConfig, simNumber);
_workTimeGenerator = new WorkTimeGenerator(simConfig.Seed, simConfig.WorkTimeDeviation, simNumber);
var timeTable = new TimeTable <ISimulationItem>(simConfig.RecalculationTime);
UpdateStockExchangesWithInitialValues(simulationId, simNumber);
//call the initial central planning
await Recalculate(timeTable, simulationId, simNumber, new List <ProductionOrderWorkSchedule>());
CreateMachinesReady(timeTable);
timeTable = UpdateGoodsDelivery(timeTable, simulationId);
return(timeTable);
}
public ActionResult Index(int length, int alphabetCardinality, bool generateStrict, short[] characteristicLinkIds)
{
return(CreateTask(() =>
{
var orderGenerator = new OrderGenerator();
var orders = generateStrict ?
orderGenerator.StrictGenerateOrders(length, alphabetCardinality) :
orderGenerator.GenerateOrders(length, alphabetCardinality);
var characteristics = new double[orders.Count][];
var sequencesCharacteristics = new List <SequenceCharacteristics>();
for (int i = 0; i < orders.Count; i++)
{
sequencesCharacteristics.Add(new SequenceCharacteristics());
}
for (int j = 0; j < orders.Count; j++)
{
var sequence = new Chain(orders[j].Select(Convert.ToInt16).ToArray());
characteristics[j] = new double[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkIds[k]);
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkIds[k]);
IFullCalculator calculator = FullCalculatorsFactory.CreateCalculator(characteristic);
characteristics[j][k] = calculator.Calculate(sequence, link);
}
sequencesCharacteristics[j] = new SequenceCharacteristics
{
MatterName = String.Join(",", orders[j].Select(n => n.ToString()).ToArray()),
Characteristics = characteristics[j]
};
}
var characteristicNames = new string[characteristicLinkIds.Length];
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k]);
characteristicsList[k] = new SelectListItem
{
Value = k.ToString(),
Text = characteristicNames[k],
Selected = false
};
}
sequencesCharacteristics.RemoveAll(el => el.Characteristics.Any(v => Double.IsInfinity(v) ||
Double.IsNaN(v) ||
Double.IsNegativeInfinity(v) ||
Double.IsPositiveInfinity(v)));
var index = new int[characteristicsList.Length];
for (int i = 0; i < index.Length; i++)
{
index[i] = i;
}
var result = new Dictionary <string, object>
{
{ "characteristics", sequencesCharacteristics.ToArray() },
{ "characteristicNames", characteristicNames },
{ "characteristicsList", characteristicsList },
{ "characteristicsIndex", index }
};
return new Dictionary <string, object>
{
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
public ActionResult Index(int length, int alphabetCardinality, int generateStrict)
{
return(CreateTask(() =>
{
var orderGenerator = new OrderGenerator();
var orders = new List <int[]>();
switch (generateStrict)
{
case 0:
orders = orderGenerator.StrictGenerateOrders(length, alphabetCardinality);
break;
case 1:
orders = orderGenerator.GenerateOrders(length, alphabetCardinality);
break;
default: throw new ArgumentException("Invalid type of generate");
}
var result = new Dictionary <string, Dictionary <Dictionary <int, int>, List <int[]> > >();
foreach (var link in EnumExtensions.ToArray <Link>())
{
if (link == Link.NotApplied)
{
continue;
}
var accordance = new Dictionary <Dictionary <int, int>, List <int[]> >();
foreach (var order in orders)
{
var sequence = new Chain(order.Select(Convert.ToInt16).ToArray());
var fullIntervals = new Dictionary <int, int>();
foreach (var el in sequence.Alphabet.ToList())
{
var congIntervals = sequence.CongenericChain(el).GetArrangement(link);
foreach (var interval in congIntervals)
{
if (fullIntervals.Any(e => e.Key == interval))
{
fullIntervals[interval]++;
}
else
{
fullIntervals.Add(interval, 1);
}
}
}
if (accordance.Keys.Any(intervals => intervals.All(i1 => fullIntervals.Any(i2 => i2.Key == i1.Key && i2.Value == i1.Value))))
{
accordance[accordance.Keys.First(intervals => intervals.All(i1 => fullIntervals.Any(i2 => i2.Key == i1.Key && i2.Value == i1.Value)))].Add(order);
}
else
{
accordance.Add(fullIntervals, new List <int[]> {
order
});
}
}
result.Add(EnumExtensions.GetDisplayValue <Link>(link), accordance);
}
var list = EnumHelper.GetSelectList(typeof(Link));
list.RemoveAt(0);
var data = new Dictionary <string, object>
{
{ "result", result.Select(r => new
{
link = r.Key.ToString(),
accordance = r.Value.Select(d => new {
distributionIntervals = d.Key.Select(pair => new
{
interval = pair.Key,
count = pair.Value
}).ToArray(),
orders = d.Value.ToArray()
})
}) },
{ "linkList", list }
};
return new Dictionary <string, object>
{
{ "data", JsonConvert.SerializeObject(data) }
};
}));
}
public ActionResult Index(int length, int alphabetCardinality, int generateStrict, short[] characteristicLinkIds)
{
// TODO: Reafctor all of this
return(CreateTask(() =>
{
var orderGenerator = new OrderGenerator();
var orders = new List <int[]>();
switch (generateStrict)
{
case 0:
orders = orderGenerator.StrictGenerateOrders(length, alphabetCardinality);
break;
case 1:
orders = orderGenerator.GenerateOrders(length, alphabetCardinality);
break;
default: throw new ArgumentException("Invalid type of generate");
}
var characteristics = new double[orders.Count][];
var sequencesCharacteristics = new List <SequenceCharacteristics>();
for (int i = 0; i < orders.Count; i++)
{
sequencesCharacteristics.Add(new SequenceCharacteristics());
}
for (int j = 0; j < orders.Count; j++)
{
var sequence = new Chain(orders[j].Select(Convert.ToInt16).ToArray());
characteristics[j] = new double[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
Link characteristicLink = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkIds[k]);
FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkIds[k]);
IFullCalculator calculator = FullCalculatorsFactory.CreateCalculator(characteristic);
characteristics[j][k] = calculator.Calculate(sequence, characteristicLink);
}
sequencesCharacteristics[j] = new SequenceCharacteristics
{
MatterName = String.Join(",", orders[j].Select(n => n.ToString()).ToArray()),
Characteristics = characteristics[j]
};
}
sequencesCharacteristics.RemoveAll(el => el.Characteristics.Any(v => Double.IsInfinity(v) ||
Double.IsNaN(v) ||
Double.IsNegativeInfinity(v) ||
Double.IsPositiveInfinity(v)));
var characteristicNames = new string[characteristicLinkIds.Length];
var characteristicsList = new SelectListItem[characteristicLinkIds.Length];
for (int k = 0; k < characteristicLinkIds.Length; k++)
{
characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k]);
characteristicsList[k] = new SelectListItem
{
Value = k.ToString(),
Text = characteristicNames[k],
Selected = false
};
}
var index = new int[characteristicsList.Length];
for (int i = 0; i < index.Length; i++)
{
index[i] = i;
}
var resultIntervals = new Dictionary <string, Dictionary <Dictionary <int, int>, Dictionary <int[], SequenceCharacteristics> > >();
foreach (var link in EnumExtensions.ToArray <Link>())
{
if (link == Link.NotApplied)
{
continue;
}
var accordance = new Dictionary <Dictionary <int, int>, Dictionary <int[], SequenceCharacteristics> >();
for (int j = 0; j < orders.Count; j++)
{
var order = orders[j];
var sequence = new Chain(order.Select(Convert.ToInt16).ToArray());
var fullIntervals = new Dictionary <int, int>();
var alphabet = sequence.Alphabet.ToList();
foreach (var el in alphabet)
{
var congIntervals = sequence.CongenericChain(el).GetArrangement(link);
foreach (var interval in congIntervals)
{
if (fullIntervals.Any(e => e.Key == interval))
{
fullIntervals[interval]++;
}
else
{
fullIntervals.Add(interval, 1);
}
}
}
if (accordance.Keys.Any(intervals => intervals.All(i1 => fullIntervals.Any(i2 => i2.Key == i1.Key && i2.Value == i1.Value))))
{
accordance[accordance.Keys.First(intervals => intervals.All(i1 => fullIntervals.Any(i2 => i2.Key == i1.Key && i2.Value == i1.Value)))].Add(order, sequencesCharacteristics.First(el => el.MatterName.SequenceEqual(String.Join(",", orders[j].Select(n => n.ToString()).ToArray()))));
}
else
{
accordance.Add(fullIntervals, new Dictionary <int[], SequenceCharacteristics> {
{
order,
sequencesCharacteristics.First(el => el.MatterName.SequenceEqual(String.Join(",", orders[j].Select(n => n.ToString()).ToArray())))
}
});
}
}
resultIntervals.Add(EnumExtensions.GetDisplayValue <Link>(link), accordance);
}
var list = EnumHelper.GetSelectList(typeof(Link));
list.RemoveAt(0);
var result = new Dictionary <string, object>
{
{ "result", resultIntervals.Select(r => new
{
link = r.Key,
accordance = r.Value.Select(d => new {
distributionIntervals = d.Key.Select(pair => new
{
interval = pair.Key,
count = pair.Value
}).ToArray(),
orders = d.Value.Select(o => new
{
order = o.Key,
characteristics = o.Value
})
})
}) },
{ "linkList", list },
{ "characteristicNames", characteristicNames },
{ "characteristicsList", characteristicsList },
{ "characteristicsIndex", index }
};
return new Dictionary <string, string> {
{ "data", JsonConvert.SerializeObject(result) }
};
}));
}
