/// <summary> /// Creates a new assetSchedule from and old assetSchedule and a new Event /// </summary> /// <param name="oldSchedule"></param> /// <param name="newEvent"></param> public StateHistory(StateHistory oldSchedule, Event newEvent) { Events = new Stack<Event>(oldSchedule.Events); InitialState = oldSchedule.InitialState; //Should maybe be a deep copy -->not for this one Events.Push(newEvent); // Asset = newAssetSched.Asset; }
/// <summary> /// Creates a new assetSchedule from and old assetSchedule and a new Event /// </summary> /// <param name="oldSchedule"></param> /// <param name="newEvent"></param> public StateHistory(StateHistory oldSchedule, Event newEvent) { Events = oldSchedule.Events; InitialState = oldSchedule.InitialState; //Should maybe be a deep copy -->no Events.Push(newEvent); // Asset = newAssetSched.Asset; }
/// <summary> /// Creates a new endstate-safe schedule from the given schedule. (last state copied as deep copy, all others shallow copies) /// </summary> /// <param name="oldSchedule"></param> public StateHistory(StateHistory oldSchedule) { InitialState = oldSchedule.InitialState; Events = new Stack <Event>(oldSchedule.Events); Events.Pop(); Events.Push(new Event(oldSchedule.Events.Peek())); }
/// <summary> /// Creates a new assetSchedule from and old assetSchedule and a new Event /// </summary> /// <param name="oldSchedule"></param> /// <param name="newEvent"></param> public StateHistory(StateHistory oldSchedule, Event newEvent) { Events = new Stack <Event>(oldSchedule.Events); InitialState = oldSchedule.InitialState; //Should maybe be a deep copy -->not for this one Events.Push(newEvent); // Asset = newAssetSched.Asset; }
public SystemSchedule(StateHistory allStates) { AllStates = new StateHistory(allStates.InitialState); foreach (var eit in allStates.Events) { AllStates.Events.Push(new Event(eit)); } }
/// <summary> /// Creates a new copy of a state history so that events can be added to it /// </summary> /// <param name="oldSchedule"></param> public StateHistory(StateHistory oldSchedule) { InitialState = oldSchedule.InitialState; Events = new Stack<Event>(); int i; Event eit; Event[] copy = new Event[oldSchedule.Events.Count] ; oldSchedule.Events.CopyTo(copy, 0); for (i = oldSchedule.Events.Count - 1; i >= 0; i--) { eit = copy[i]; Events.Push(eit); } }
public SystemSchedule(SystemSchedule oldSchedule, Stack <Access> newAccessList, double newEventStartTime) { Dictionary <Asset, Task> tasks = new Dictionary <Asset, Task>(); Dictionary <Asset, double> taskStarts = new Dictionary <Asset, double>(); Dictionary <Asset, double> taskEnds = new Dictionary <Asset, double>(); Dictionary <Asset, double> eventStarts = new Dictionary <Asset, double>(); Dictionary <Asset, double> eventEnds = new Dictionary <Asset, double>(); foreach (var access in newAccessList) { tasks.Add(access.Asset, access.Task); //shold this be a deep copy if (access.AccessStart < newEventStartTime && newEventStartTime < access.AccessEnd) { taskStarts.Add(access.Asset, newEventStartTime); } else { taskStarts.Add(access.Asset, access.AccessStart); } taskEnds.Add(access.Asset, access.AccessEnd); eventStarts.Add(access.Asset, newEventStartTime); eventEnds.Add(access.Asset, newEventStartTime + SchedParameters.SimStepSeconds); } Event eventToAdd = new Event(tasks, new SystemState(oldSchedule.GetEndState())); //all references eventToAdd.SetEventEnd(eventEnds); eventToAdd.SetTaskEnd(taskEnds); eventToAdd.SetEventStart(eventStarts); eventToAdd.SetTaskStart(taskStarts); AllStates = new StateHistory(oldSchedule.AllStates, eventToAdd); /* commented out because it doesn't work yet * // TODO (EAM): Changed this so we need to double check/test * //int i = 0; //need a double iterator * foreach(var assetSchedAccess in newAccessList) * { * Task task = DeepCopy.Copy<Task>(assetSchedAccess.Task); * if (task != null) * { * Event eventToAdd = new Event(task, new SystemState(assetSchedAccess.Item1.GetLastState(), newTaskStartTime)); * AssetScheds.Add(new StateHistory(assetSchedAccess.Item1, eventToAdd, assetSchedAccess.Item2.Asset)); * //TODO: double check c# implementation above * // shared_ptr<Event> eventToAdd(new Event(*tIt, new State((*assSchedIt)->getLastState(), newTaskStartTime))); * // assetscheds.push_back(new assetSchedule(*assSchedIt, eventToAdd)); * } * else * AssetScheds.Add(DeepCopy.Copy<StateHistory>(assetSchedAccess.Item1)); * } */ }
/// <summary> /// Creates a new copy of a state history so that events can be added to it /// </summary> /// <param name="oldSchedule"></param> public StateHistory(StateHistory oldSchedule) { InitialState = oldSchedule.InitialState; Events = new Stack <Event>(); int i; Event eit; Event[] copy = new Event[oldSchedule.Events.Count]; oldSchedule.Events.CopyTo(copy, 0); for (i = oldSchedule.Events.Count - 1; i >= 0; i--) { eit = copy[i]; Events.Push(eit); } }
/// <summary> /// Generate schedules by adding a new event to the end of existing ones /// Create a new system schedule list by adding each of the new Task commands for the Assets onto each of the old schedules /// </summary> /// <param name="system"></param> /// <param name="tasks"></param> /// <param name="initialStateList"></param> /// <returns></returns> public virtual List <SystemSchedule> GenerateSchedules(SystemClass system, Stack <Task> tasks, SystemState initialStateList) { log.Info("SIMULATING... "); // Create empty systemSchedule with initial state set SystemSchedule emptySchedule = new SystemSchedule(initialStateList); List <SystemSchedule> systemSchedules = new List <SystemSchedule>(); systemSchedules.Add(emptySchedule); // if all asset position types are not dynamic types, can pregenerate accesses for the simulation bool canPregenAccess = true; foreach (var asset in system.Assets) { if (asset.AssetDynamicState != null) { canPregenAccess &= asset.AssetDynamicState.Type != HSFUniverse.DynamicStateType.DYNAMIC_ECI && asset.AssetDynamicState.Type != HSFUniverse.DynamicStateType.DYNAMIC_LLA; } else { canPregenAccess = false; } } // if accesses can be pregenerated, do it now Stack <Access> preGeneratedAccesses = new Stack <Access>(); Stack <Stack <Access> > scheduleCombos = new Stack <Stack <Access> >(); if (canPregenAccess) { log.Info("Pregenerating Accesses..."); //DWORD startPregenTickCount = GetTickCount(); preGeneratedAccesses = Access.pregenerateAccessesByAsset(system, tasks, _startTime, _endTime, _stepLength); //DWORD endPregenTickCount = GetTickCount(); //pregenTimeMs = endPregenTickCount - startPregenTickCount; //writeAccessReport(access_pregen, tasks); - TODO: Finish this code - EAM log.Info("Done pregenerating accesses"); } // otherwise generate an exhaustive list of possibilities for assetTaskList else { log.Info("Generating Exhaustive Task Combinations... "); Stack <Stack <Access> > exhaustive = new Stack <Stack <Access> >(); Stack <Access> allAccesses = new Stack <Access>(tasks.Count); foreach (var asset in system.Assets) { foreach (var task in tasks) { allAccesses.Push(new Access(asset, task)); } allAccesses.Push(new Access(asset, null)); exhaustive.Push(allAccesses); allAccesses.Clear(); } scheduleCombos = (Stack <Stack <Access> >)exhaustive.CartesianProduct(); log.Info("Done generating exhaustive task combinations"); } /// TODO: Delete (or never create in the first place) schedules with inconsistent asset tasks (because of asset dependencies) // Find the next timestep for the simulation //DWORD startSchedTickCount = GetTickCount(); int i = 1; List <SystemSchedule> potentialSystemSchedules = new List <SystemSchedule>(); List <SystemSchedule> systemCanPerformList = new List <SystemSchedule>(); for (double currentTime = _startTime; currentTime < _endTime; currentTime += _stepLength) { log.Info("Simulation Time " + currentTime); // if accesses are pregenerated, look up the access information and update assetTaskList if (canPregenAccess) { scheduleCombos = GenerateExhaustiveSystemSchedules(preGeneratedAccesses, system, currentTime); } // Check if it's necessary to crop the systemSchedule list to a more managable number if (systemSchedules.Count > _maxNumSchedules) { log.Info("Cropping " + systemSchedules.Count + " Schedules."); CropSchedules(systemSchedules, ScheduleEvaluator, emptySchedule); systemSchedules.Add(emptySchedule); } // Generate an exhaustive list of new tasks possible from the combinations of Assets and Tasks //TODO: Parallelize this. int k = 0; foreach (var oldSystemSchedule in systemSchedules) { potentialSystemSchedules.Add(new SystemSchedule(new StateHistory(oldSystemSchedule.AllStates))); foreach (var newAccessStack in scheduleCombos) { k++; if (oldSystemSchedule.CanAddTasks(newAccessStack, currentTime)) { var CopySchedule = new StateHistory(oldSystemSchedule.AllStates); potentialSystemSchedules.Add(new SystemSchedule(CopySchedule, newAccessStack, currentTime)); // oldSched = new SystemSchedule(CopySchedule); } } } int numSched = 0; foreach (var potentialSchedule in potentialSystemSchedules) { if (Checker.CheckSchedule(system, potentialSchedule)) { systemCanPerformList.Add(potentialSchedule); } numSched++; } foreach (SystemSchedule systemSchedule in systemCanPerformList) { systemSchedule.ScheduleValue = ScheduleEvaluator.Evaluate(systemSchedule); } systemCanPerformList.Sort((x, y) => x.ScheduleValue.CompareTo(y.ScheduleValue)); systemCanPerformList.Reverse(); // Merge old and new systemSchedules var oldSystemCanPerfrom = new List <SystemSchedule>(systemCanPerformList); systemSchedules.InsertRange(0, oldSystemCanPerfrom);//<--This was potentialSystemSchedules potentialSystemSchedules.Clear(); systemCanPerformList.Clear(); // Print completion percentage in command window Console.WriteLine("Scheduler Status: {0}% done; {1} schedules generated.", 100 * currentTime / _endTime, systemSchedules.Count); } return(systemSchedules); }
public SystemSchedule(StateHistory oldStates, Stack <Access> newAccessList, double newEventStartTime) { Dictionary <Asset, Task> tasks = new Dictionary <Asset, Task>(); Dictionary <Asset, double> taskStarts = new Dictionary <Asset, double>(); Dictionary <Asset, double> taskEnds = new Dictionary <Asset, double>(); Dictionary <Asset, double> eventStarts = new Dictionary <Asset, double>(); Dictionary <Asset, double> eventEnds = new Dictionary <Asset, double>(); foreach (var access in newAccessList) { if (access.Task != null) { if (access.AccessStart <= newEventStartTime && newEventStartTime <= access.AccessEnd) { taskStarts.Add(access.Asset, newEventStartTime); } else if (access.AccessStart >= newEventStartTime && access.AccessStart <= newEventStartTime + SchedParameters.SimStepSeconds) { taskStarts.Add(access.Asset, access.AccessStart); } else { Console.WriteLine("Event Start: " + newEventStartTime + " AccesStart: " + access.AccessStart + " AccessEnd: " + access.AccessEnd); taskStarts.Add(access.Asset, newEventStartTime); } tasks.Add(access.Asset, access.Task); if (access.AccessEnd > SimParameters.SimEndSeconds) { taskEnds.Add(access.Asset, SimParameters.SimEndSeconds); } else { taskEnds.Add(access.Asset, access.AccessEnd); } eventStarts.Add(access.Asset, newEventStartTime); if (newEventStartTime + SchedParameters.SimStepSeconds > SimParameters.SimEndSeconds) { eventEnds.Add(access.Asset, SchedParameters.SimStepSeconds); } else { eventEnds.Add(access.Asset, newEventStartTime + SchedParameters.SimStepSeconds); } } else { taskStarts.Add(access.Asset, newEventStartTime); taskEnds.Add(access.Asset, newEventStartTime); tasks.Add(access.Asset, null); eventStarts.Add(access.Asset, newEventStartTime); eventEnds.Add(access.Asset, newEventStartTime + SchedParameters.SimStepSeconds); } } Event eventToAdd = new Event(tasks, new SystemState(oldStates.GetLastState())); //all references eventToAdd.SetEventEnd(eventEnds); eventToAdd.SetTaskEnd(taskEnds); eventToAdd.SetEventStart(eventStarts); eventToAdd.SetTaskStart(taskStarts); AllStates = new StateHistory(oldStates, eventToAdd); }
public SystemSchedule(SystemSchedule oldSchedule, Event emptyEvent) { AllStates = new StateHistory(oldSchedule.AllStates); AllStates.Events.Push(emptyEvent); }
public SystemSchedule(SystemState initialstates) { ScheduleValue = 0; AllStates = new StateHistory(initialstates); }
/// <summary> /// Copy constructor to preserve the without adding a task /// </summary> /// <param name="oldSchedule"></param> public SystemSchedule(SystemSchedule oldSchedule) { AllStates = new StateHistory(oldSchedule.AllStates); }
/// <summary> /// Generate schedules by adding a new event to the end of existing ones /// Create a new system schedule list by adding each of the new Task commands for the Assets onto each of the old schedules /// </summary> /// <param name="system"></param> /// <param name="tasks"></param> /// <param name="initialStateList"></param> /// <returns></returns> public virtual List<SystemSchedule> GenerateSchedules(SystemClass system, Stack<Task> tasks, SystemState initialStateList) { log.Info("SIMULATING... "); // Create empty systemSchedule with initial state set SystemSchedule emptySchedule = new SystemSchedule(initialStateList); List<SystemSchedule> systemSchedules = new List<SystemSchedule>(); systemSchedules.Add(emptySchedule); // if all asset position types are not dynamic types, can pregenerate accesses for the simulation bool canPregenAccess = true; foreach (var asset in system.Assets) { if(asset.AssetDynamicState != null) canPregenAccess &= asset.AssetDynamicState.Type != HSFUniverse.DynamicStateType.DYNAMIC_ECI && asset.AssetDynamicState.Type != HSFUniverse.DynamicStateType.DYNAMIC_LLA; else canPregenAccess = false; } // if accesses can be pregenerated, do it now Stack<Access> preGeneratedAccesses = new Stack<Access>(); Stack<Stack<Access>> scheduleCombos = new Stack<Stack<Access>>(); if (canPregenAccess) { log.Info("Pregenerating Accesses..."); //DWORD startPregenTickCount = GetTickCount(); preGeneratedAccesses = Access.pregenerateAccessesByAsset(system, tasks, _startTime, _endTime, _stepLength); //DWORD endPregenTickCount = GetTickCount(); //pregenTimeMs = endPregenTickCount - startPregenTickCount; //writeAccessReport(access_pregen, tasks); - TODO: Finish this code - EAM log.Info("Done pregenerating accesses"); } // otherwise generate an exhaustive list of possibilities for assetTaskList else { log.Info("Generating Exhaustive Task Combinations... "); Stack<Stack<Access>> exhaustive = new Stack<Stack<Access>>(); Stack<Access> allAccesses = new Stack<Access>(tasks.Count); foreach (var asset in system.Assets) { foreach (var task in tasks) allAccesses.Push(new Access(asset, task)); allAccesses.Push(new Access(asset, null)); exhaustive.Push(allAccesses); allAccesses.Clear(); } scheduleCombos = (Stack<Stack<Access>>)exhaustive.CartesianProduct(); log.Info("Done generating exhaustive task combinations"); } /// TODO: Delete (or never create in the first place) schedules with inconsistent asset tasks (because of asset dependencies) // Find the next timestep for the simulation //DWORD startSchedTickCount = GetTickCount(); int i = 1; List<SystemSchedule> potentialSystemSchedules = new List<SystemSchedule>(); List<SystemSchedule> systemCanPerformList = new List<SystemSchedule>(); for (double currentTime = _startTime; currentTime < _endTime; currentTime += _stepLength) { log.Info("Simulation Time " + currentTime); // if accesses are pregenerated, look up the access information and update assetTaskList if (canPregenAccess) scheduleCombos = GenerateExhaustiveSystemSchedules(preGeneratedAccesses, system, currentTime); // Check if it's necessary to crop the systemSchedule list to a more managable number if (systemSchedules.Count > _maxNumSchedules) { log.Info("Cropping Schedules..."); CropSchedules(systemSchedules, ScheduleEvaluator, emptySchedule); systemSchedules.Add(emptySchedule); } // Generate an exhaustive list of new tasks possible from the combinations of Assets and Tasks //TODO: Parallelize this. int k = 0; foreach (var oldSystemSchedule in systemSchedules) { potentialSystemSchedules.Add(new SystemSchedule( new StateHistory(oldSystemSchedule.AllStates))); foreach (var newAccessStack in scheduleCombos) { k++; if (oldSystemSchedule.CanAddTasks(newAccessStack, currentTime)) { var CopySchedule = new StateHistory(oldSystemSchedule.AllStates); potentialSystemSchedules.Add(new SystemSchedule(CopySchedule, newAccessStack, currentTime)); // oldSched = new SystemSchedule(CopySchedule); } } } int numSched = 0; foreach (var potentialSchedule in potentialSystemSchedules) { if (Checker.CheckSchedule(system, potentialSchedule)) systemCanPerformList.Add(potentialSchedule); numSched++; } foreach (SystemSchedule systemSchedule in systemCanPerformList) systemSchedule.ScheduleValue = ScheduleEvaluator.Evaluate(systemSchedule); systemCanPerformList.Sort((x, y) => x.ScheduleValue.CompareTo(y.ScheduleValue)); systemCanPerformList.Reverse(); // Merge old and new systemSchedules var oldSystemCanPerfrom = new List<SystemSchedule>(systemCanPerformList); systemSchedules.InsertRange(0, oldSystemCanPerfrom);//<--This was potentialSystemSchedules potentialSystemSchedules.Clear(); systemCanPerformList.Clear(); // Print completion percentage in command window Console.WriteLine("Scheduler Status: {0}% done; {1} schedules generated.", 100 * currentTime / _endTime, systemSchedules.Count); } return systemSchedules; }
public SystemSchedule(StateHistory allStates) { AllStates = new StateHistory(allStates); }