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)); }