public LayoutGenerator(
LayoutConfiguration layoutConfiguration,
IRandomizer rand,
SettingConfiguration baseConfiguration,
ControlConfiguration controlConfiguration,
Action <string> logAction = null)
{
_logAction = logAction;
String errorMessage = "";
if (!layoutConfiguration.isValid(out errorMessage))
{
throw new ArgumentException("LayoutConfiguration is not valid. " + errorMessage);
}
baseConfiguration.InventoryConfiguration.autogenerate();
if (!baseConfiguration.InventoryConfiguration.isValid(layoutConfiguration.PodCapacity, out errorMessage))
{
throw new ArgumentException("InventoryConfiguration is not valid. " + errorMessage);
}
if (!controlConfiguration.IsValid(out errorMessage))
{
throw new ArgumentException("ControlConfiguration is not valid. " + errorMessage);
}
this.rand = rand;
this.baseConfiguration = baseConfiguration;
elevatorPositions = new Dictionary <Tuple <double, double>, Elevator>();
elevatorWaypoints = new Dictionary <Elevator, List <Waypoint> >();
elevatorSemaphores = new Dictionary <Waypoint, QueueSemaphore>();
instance = Instance.CreateInstance(this.baseConfiguration, controlConfiguration);
instance.Name = layoutConfiguration.NameLayout;
this.lc = layoutConfiguration;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="settingConfig">The configuration for the setting to emulate.</param>
/// <param name="controlConfig">The configuration for the controllers.</param>
/// <returns>The newly created instance.</returns>
public static Instance CreateInstance(SettingConfiguration settingConfig, ControlConfiguration controlConfig)
{
Instance instance = new Instance()
{
SettingConfig = (settingConfig != null) ? settingConfig : new SettingConfiguration(),
ControllerConfig = (controlConfig != null) ? controlConfig : new ControlConfiguration(),
};
return(instance);
}
/// <summary>
/// Generates an instance with the given layout and configuration attached.
/// </summary>
/// <param name="layoutConfiguration">The layout configuration defining all the instance characteristics.</param>
/// <param name="rand">A randomizer that is used during generation.</param>
/// <param name="settingConfig">The configuration for the setting to emulate that will be attached for executing the simulation afterwards.</param>
/// <param name="controlConfig">The configuration for the controlling mechanisms that will be attached for executing the simulation afterwards.</param>
/// <param name="logAction">An optional action for logging.</param>
/// <returns>The generated instance.</returns>
public static Instance GenerateLayout(
LayoutConfiguration layoutConfiguration,
IRandomizer rand,
SettingConfiguration settingConfig,
ControlConfiguration controlConfig,
Action <string> logAction = null)
{
LayoutGenerator layoutGenerator = new LayoutGenerator(layoutConfiguration, rand, settingConfig, controlConfig, logAction);
Instance instance = layoutGenerator.GenerateLayout();
InitializeInstance(instance);
return(instance);
}
/// <summary>
/// Reads an instance from a file.
/// </summary>
/// <param name="instancePath">The path to either the instance or a layout configuration.</param>
/// <param name="settingConfigPath">The path to the file specifying the setting.</param>
/// <param name="controlConfigPath">The path to the file supplying the configuration for all controlling mechanisms.</param>
/// <param name="overrideVisualizationAttached">Indicates whether a visualization shall be attached.</param>
/// <param name="visualizationOnly">If this is enabled most of the initialization will be skipped.</param>
/// <param name="logAction">A action that will be used for logging some lines.</param>
/// <returns></returns>
public static Instance ReadInstance(
string instancePath,
string settingConfigPath,
string controlConfigPath,
bool overrideVisualizationAttached = false,
bool visualizationOnly = false,
Action <string> logAction = null)
{
// Test for layout / instance file
XmlDocument doc = new XmlDocument();
doc.Load(instancePath);
string rootName = doc.SelectSingleNode("/*").Name;
bool layoutConfigurationGiven = false;
if (rootName == nameof(Instance))
{
layoutConfigurationGiven = false;
}
else if (rootName == nameof(LayoutConfiguration))
{
layoutConfigurationGiven = true;
}
else
{
throw new ArgumentException("No valid instance or layout file given!");
}
logAction?.Invoke(rootName + " recognized!");
// --> Read configurations
SettingConfiguration settingConfig = null;
ControlConfiguration controlConfig = null;
LayoutConfiguration layoutConfig = null;
if (!visualizationOnly)
{
// Read the setting configuration
logAction?.Invoke("Parsing setting config ...");
using (StreamReader sr = new StreamReader(settingConfigPath))
{
// Deserialize the xml-file
settingConfig = (SettingConfiguration)_settingConfigSerializer.Deserialize(sr);
// If it contains a path to a word-file that is not leading to a wordlist file try the default wordlist locations
if (settingConfig.InventoryConfiguration.ColoredWordConfiguration != null &&
!File.Exists(settingConfig.InventoryConfiguration.ColoredWordConfiguration.WordFile))
{
settingConfig.InventoryConfiguration.ColoredWordConfiguration.WordFile =
IOHelper.FindResourceFile(settingConfig.InventoryConfiguration.ColoredWordConfiguration.WordFile, instancePath);
}
// If it contains a path to an order-file that is not leading to a orderlist file try the default orderlist locations
if (settingConfig.InventoryConfiguration.FixedInventoryConfiguration != null &&
!string.IsNullOrWhiteSpace(settingConfig.InventoryConfiguration.FixedInventoryConfiguration.OrderFile) &&
!File.Exists(settingConfig.InventoryConfiguration.FixedInventoryConfiguration.OrderFile))
{
settingConfig.InventoryConfiguration.FixedInventoryConfiguration.OrderFile =
IOHelper.FindResourceFile(settingConfig.InventoryConfiguration.FixedInventoryConfiguration.OrderFile, instancePath);
}
// If it contains a path to an simple-item-file that is not leading to a generator config file try the default locations
if (settingConfig.InventoryConfiguration.SimpleItemConfiguration != null &&
!string.IsNullOrWhiteSpace(settingConfig.InventoryConfiguration.SimpleItemConfiguration.GeneratorConfigFile) &&
!File.Exists(settingConfig.InventoryConfiguration.SimpleItemConfiguration.GeneratorConfigFile))
{
settingConfig.InventoryConfiguration.SimpleItemConfiguration.GeneratorConfigFile =
IOHelper.FindResourceFile(settingConfig.InventoryConfiguration.SimpleItemConfiguration.GeneratorConfigFile, instancePath);
}
}
// Read the control configuration
logAction?.Invoke("Parsing control config ...");
using (StreamReader sr = new StreamReader(controlConfigPath))
// Deserialize the xml-file
controlConfig = (ControlConfiguration)_controlConfigSerializer.Deserialize(sr);
}
// --> Init or generate instance
Instance instance = null;
if (layoutConfigurationGiven)
{
// Read the layout configuration
logAction?.Invoke("Parsing layout config ...");
using (StreamReader sr = new StreamReader(instancePath))
// Deserialize the xml-file
layoutConfig = (LayoutConfiguration)_layoutConfigSerializer.Deserialize(sr);
// Apply override config, if available
if (settingConfig != null && settingConfig.OverrideConfig != null)
{
layoutConfig.ApplyOverrideConfig(settingConfig.OverrideConfig);
}
// Generate instance
logAction?.Invoke("Generating instance...");
instance = InstanceGenerator.GenerateLayout(layoutConfig, new RandomizerSimple(0), settingConfig, controlConfig, logAction);
}
else
{
// Init the instance object
instance = new Instance();
}
// Check whether the config is required
if (!visualizationOnly)
{
// Submit config first to the instance object
instance.SettingConfig = settingConfig;
instance.ControllerConfig = controlConfig;
}
else
{
// Add default config (none required though)
instance.SettingConfig = new SettingConfiguration();
instance.SettingConfig.VisualizationOnly = true;
instance.ControllerConfig = new ControlConfiguration();
}
// If a visualization is already present set it to true
instance.SettingConfig.VisualizationAttached = overrideVisualizationAttached;
// --> Parse the instance from a file, if no layout was given but a specific instance
if (!layoutConfigurationGiven)
{
// Read the instance
logAction?.Invoke("Parsing instance ...");
using (StreamReader sr = new StreamReader(instancePath))
{
// Deserialize the xml-file
DTOInstance dtoInstance = (DTOInstance)_instanceSerializer.Deserialize(sr);
// Submit the data to an instance object
dtoInstance.Submit(instance);
}
}
// Return it
return(instance);
}
/// <summary>
/// Writes the configuration to a file.
/// </summary>
/// <param name="path">The file.</param>
/// <param name="config">The configuration.</param>
public static void WriteConfiguration(string path, ControlConfiguration config)
{
// Serialize it
using (TextWriter writer = new StreamWriter(path))
_controlConfigSerializer.Serialize(writer, config);
}
public static void GenerateRepositioningSet3()
{
Dictionary <bool, StationActivationConfiguration> stationControllers = new Dictionary <bool, StationActivationConfiguration>()
{
{ false, new ActivateAllStationActivationConfiguration() },
{ true, new WorkShiftStationActivationConfiguration(new DefaultConstructorIdentificationClass()) },
};
List <Tuple <double, double> > speedUtilityWeights = new List <Tuple <double, double> >()
{
new Tuple <double, double>(0, 1),
new Tuple <double, double>(1, 0),
new Tuple <double, double>(1, 1),
};
List <Tuple <PodStorageConfiguration, RepositioningConfiguration> > positioningControllers = new List <Tuple <PodStorageConfiguration, RepositioningConfiguration> >()
{
new Tuple <PodStorageConfiguration, RepositioningConfiguration>(
new NearestPodStorageConfiguration(),
new UtilityRepositioningConfiguration()),
new Tuple <PodStorageConfiguration, RepositioningConfiguration>(
new NearestPodStorageConfiguration(),
new CacheDropoffRepositioningConfiguration()),
new Tuple <PodStorageConfiguration, RepositioningConfiguration>(
new UtilityPodStorageConfiguration(),
new UtilityRepositioningConfiguration()),
new Tuple <PodStorageConfiguration, RepositioningConfiguration>(
new CachePodStorageConfiguration(),
new CacheDropoffRepositioningConfiguration()),
};
List <OrderBatchingConfiguration> orderBatchers = new List <OrderBatchingConfiguration>()
{
new DefaultOrderBatchingConfiguration()
{
OrderSelectionRule = Core.Control.Defaults.OrderBatching.DefaultOrderSelection.FCFS,
StationSelectionRule = Core.Control.Defaults.OrderBatching.DefaultOutputStationSelection.Random,
},
};
List <RepositioningSubExperiment> subExperiments = new List <RepositioningSubExperiment>()
{
new RepositioningSubExperiment()
{
NightDown = false, BotsPerOStation = 4, BotAllocation = new Tuple <bool, double, double, double>(false, 1, 3, 0)
},
new RepositioningSubExperiment()
{
NightDown = false, BotsPerOStation = 4, BotAllocation = new Tuple <bool, double, double, double>(true, 1, 2, 1)
},
new RepositioningSubExperiment()
{
NightDown = false, BotsPerOStation = 5, BotAllocation = new Tuple <bool, double, double, double>(true, 1, 3, 1)
},
new RepositioningSubExperiment()
{
NightDown = true, BotsPerOStation = 4, BotAllocation = new Tuple <bool, double, double, double>(true, 1, 3, 0)
},
new RepositioningSubExperiment()
{
NightDown = true, BotsPerOStation = 4, BotAllocation = new Tuple <bool, double, double, double>(false, 1, 3, 0)
},
};
int counter = 0;
foreach (var subExperiment in subExperiments)
{
string dir = "SubExp" + (++counter);
while (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
foreach (var speedUtilityWeight in speedUtilityWeights)
{
foreach (var positioningController in positioningControllers)
{
foreach (var orderBatcher in orderBatchers)
{
// Prepare setting
SettingConfiguration setting = GetRepositioningBaseSetting();
setting.OverrideConfig = new OverrideConfiguration()
{
OverrideBotCountPerOStation = true,
OverrideBotCountPerOStationValue = subExperiment.BotsPerOStation,
};
if (subExperiment.NightDown)
{
setting.InventoryConfiguration.DemandInventoryConfiguration.BundleCount = 0;
setting.InventoryConfiguration.SubmitBatches = true;
setting.InventoryConfiguration.BatchInventoryConfiguration = new BatchInventoryConfiguration()
{
MaxTimeForBundleSubmissions = TimeSpan.FromDays(1).TotalSeconds,
MaxTimeForOrderSubmissions = TimeSpan.FromDays(1).TotalSeconds,
BundleBatches = new List <Skvp <double, double> >()
{
new Skvp <double, double>()
{
Key = TimeSpan.FromHours(16).TotalSeconds, Value = 0.75
}
},
OrderBatches = new List <Skvp <double, int> >()
{
new Skvp <double, int>()
{
Key = TimeSpan.FromHours(22).TotalSeconds, Value = 1500
}
},
};
}
// Prepare config
ControlConfiguration config = new ControlConfiguration()
{
StationActivationConfig = stationControllers[subExperiment.NightDown],
TaskAllocationConfig = new BalancedTaskAllocationConfiguration()
{
RepositionBeforeRest = subExperiment.BotAllocation.Item1,
WeightInputStations = subExperiment.BotAllocation.Item2,
WeightOutputStations = subExperiment.BotAllocation.Item3,
WeightRepositioning = subExperiment.BotAllocation.Item4,
},
OrderBatchingConfig = orderBatcher,
PodStorageConfig = positioningController.Item1,
RepositioningConfig = positioningController.Item2,
};
// Set weights
if (config.PodStorageConfig is CachePodStorageConfiguration)
{
(config.PodStorageConfig as CachePodStorageConfiguration).WeightSpeed = speedUtilityWeight.Item1;
(config.PodStorageConfig as CachePodStorageConfiguration).WeightUtility = speedUtilityWeight.Item2;
}
if (config.PodStorageConfig is UtilityPodStorageConfiguration)
{
(config.PodStorageConfig as UtilityPodStorageConfiguration).UtilityConfig.WeightSpeed = speedUtilityWeight.Item1;
(config.PodStorageConfig as UtilityPodStorageConfiguration).UtilityConfig.WeightUtility = speedUtilityWeight.Item2;
}
if (config.RepositioningConfig is CacheDropoffRepositioningConfiguration)
{
(config.RepositioningConfig as CacheDropoffRepositioningConfiguration).WeightSpeed = speedUtilityWeight.Item1;
(config.RepositioningConfig as CacheDropoffRepositioningConfiguration).WeightUtility = speedUtilityWeight.Item2;
}
if (config.RepositioningConfig is UtilityRepositioningConfiguration)
{
(config.RepositioningConfig as UtilityRepositioningConfiguration).UtilityConfig.WeightSpeed = speedUtilityWeight.Item1;
(config.RepositioningConfig as UtilityRepositioningConfiguration).UtilityConfig.WeightUtility = speedUtilityWeight.Item2;
}
// Name setting
setting.Name = "ScenRep-" + (subExperiment.NightDown ? "NightDown" : "NoDown") + "-BPOS" + subExperiment.BotsPerOStation;
// Name controller
string saTag;
if (config.StationActivationConfig is ActivateAllStationActivationConfiguration)
{
saTag = "A";
}
else if (config.StationActivationConfig is WorkShiftStationActivationConfiguration)
{
saTag = "W";
}
else
{
throw new ArgumentException("Unknown!");
}
string psTag;
if (config.PodStorageConfig is RandomPodStorageConfiguration)
{
psTag = "R";
}
else if (config.PodStorageConfig is NearestPodStorageConfiguration)
{
psTag = "N";
}
else if (config.PodStorageConfig is CachePodStorageConfiguration)
{
psTag = "C";
}
else if (config.PodStorageConfig is UtilityPodStorageConfiguration)
{
psTag = "U";
}
else
{
throw new ArgumentException("Unknown!");
}
string rpTag;
if (config.RepositioningConfig is DummyRepositioningConfiguration)
{
rpTag = "D";
}
else if (config.RepositioningConfig is CacheDropoffRepositioningConfiguration)
{
rpTag = "C";
}
else if (config.RepositioningConfig is UtilityRepositioningConfiguration)
{
rpTag = "U";
}
else
{
throw new ArgumentException("Unknown!");
}
string obTag;
if (config.OrderBatchingConfig is QueueOrderBatchingConfiguration)
{
obTag = "Q";
}
else if (config.OrderBatchingConfig is PodMatchingOrderBatchingConfiguration)
{
obTag = "M";
}
else if (config.OrderBatchingConfig is DefaultOrderBatchingConfiguration)
{
obTag = "D";
}
else
{
throw new ArgumentException("Unknown!");
}
config.Name =
"PS" + psTag + "-" +
"RP" + rpTag + "-" +
"SA" + saTag + "-" +
"OB" + obTag + "-" +
"Bot" + (subExperiment.BotAllocation.Item1 ? "t" : "f") + "I" + subExperiment.BotAllocation.Item2 + "O" + subExperiment.BotAllocation.Item3 + "R" + subExperiment.BotAllocation.Item4 + "-" +
"Wei" +
speedUtilityWeight.Item1.ToString(IOConstants.EXPORT_FORMAT_SHORTER, IOConstants.FORMATTER) +
speedUtilityWeight.Item2.ToString(IOConstants.EXPORT_FORMAT_SHORTER, IOConstants.FORMATTER);
// Save it
string fileNameController = Path.Combine(dir, config.Name + ".xconf");
Console.WriteLine("Saving " + fileNameController + " ...");
InstanceIO.WriteConfiguration(fileNameController, config);
string fileNameSetting = Path.Combine(dir, setting.Name + ".xsett");
Console.WriteLine("Saving " + fileNameSetting + " ...");
InstanceIO.WriteSetting(fileNameSetting, setting);
}
}
}
}
}
/// <summary>
/// Generates the nano default layout.
/// </summary>
/// <param name="rand">A randomizer that is used during generation.</param>
/// <param name="settingConfig">The configuration for the setting to emulate that will be attached for executing the simulation afterwards.</param>
/// <param name="controlConfig">The configuration for the controlling mechanisms that will be attached for executing the simulation afterwards.</param>
/// <returns>The generated instance.</returns>
public static Instance GenerateMaTiLayoutNano(IRandomizer rand, SettingConfiguration settingConfig, ControlConfiguration controlConfig)
{
LayoutConfiguration layoutConfiguration = GenerateMaTiLayoutConfiguration();
layoutConfiguration.BotCount = 8;
layoutConfiguration.NameLayout = "MaTiNano";
layoutConfiguration.NrHorizontalAisles = 4;
layoutConfiguration.NrVerticalAisles = 4;
layoutConfiguration.NPickStationWest = 0;
layoutConfiguration.NPickStationEast = 2;
layoutConfiguration.NPickStationSouth = 0;
layoutConfiguration.NPickStationNorth = 0;
layoutConfiguration.NReplenishmentStationWest = 2;
layoutConfiguration.NReplenishmentStationEast = 0;
layoutConfiguration.NReplenishmentStationSouth = 0;
layoutConfiguration.NReplenishmentStationNorth = 0;
return(GenerateLayout(layoutConfiguration, rand, settingConfig, controlConfig));
}
