private static bool checkSub(Subsystem subsystem, SystemSchedule proposedSchedule, Universe environment) { // new system state of the proposedSchedule (by asset). Empty to start, fully populated after Checker.CheckSchedule is done //SystemState newState = proposedSchedule.AllStates.GetLastState(); // the system state at the end of the last event on the proposedSchedule // SystemState oldState = newState.Previous; // the proposed Task // Dictionary<Asset, Task> proposedTask = new Dictionary<Asset, Task>(); // proposedTask.Add(subsystem.Asset, proposedSchedule.getSubsytemNewTask(subsystem.Asset)); //NEED A PROPOSED EVENT-- this is just a place holder // Event proposedEvent = new Event(proposedSchedule.AllStates.Events.Peek()., newState); // the dynamicState of the proposedSchedule // DynamicState assetDynamicState = subsystem.Asset.AssetDynamicState; // Check all subsystems to see if they canPerform the task // Recursion of the subsystem dependencies is managed by the subsystems SystemState oldState = proposedSchedule.AllStates.Events.Peek().State.Previous; if (oldState == null) { oldState = proposedSchedule.AllStates.InitialState; } if (!subsystem.canPerform(proposedSchedule.AllStates.Events.Peek(), environment)) { return(false); } return(true); }
/// <summary> /// Determine if the system can execute the proposed schedule /// </summary> /// <param name="system"></param> /// <param name="proposedSchedule"></param> /// <returns></returns> public static bool CheckSchedule(SystemClass system, SystemSchedule proposedSchedule) { // Iterate through Subsystem Nodes and set that they havent run foreach (var subsystem in system.Subsystems) { subsystem.IsEvaluated = false; } // Iterate through constraints foreach (var constraint in system.Constraints) { foreach (Subsystem sub in constraint.Subsystems) { if (!checkSub(sub, proposedSchedule, system.Environment)) { return(false); } if (!CheckConstraints(system, proposedSchedule, constraint)) { return(false); } //if (!constraint.accepts(proposedSchedule)) // return false; } } // Check the remaining Subsystems that aren't included in any Constraints if (!checkSubs(system.Subsystems, proposedSchedule, system.Environment)) { return(false); } return(true); }
/// <summary> /// Check if the constraint has been violated in progressing the state of the system /// </summary> /// <param name="system"></param> /// <param name="proposedSchedule"></param> /// <param name="constraint"></param> /// <returns></returns> private static bool CheckConstraints(SystemClass system, SystemSchedule proposedSchedule, Constraint constraint) { if (!constraint.Accepts(proposedSchedule.AllStates.GetLastState())) { // TODO: Change this to logger // HSFLogger.Log(new HSFLogData(constraint, subsystem, task, value, time)); Console.WriteLine("Constraint Failed"); return(false); } return(true); }
/// <summary> /// See if all the subsystems can perform the most recent task that was added to the schedule /// </summary> /// <param name="subsystems"></param> /// <param name="proposedSchedule"></param> /// <param name="environment"></param> /// <returns></returns> private static bool checkSubs(List <Subsystem> subsystems, SystemSchedule proposedSchedule, Universe environment) { foreach (var sub in subsystems) { if (!sub.IsEvaluated && !checkSub(sub, proposedSchedule, environment)) { return(false); } } return(true); }
private static bool CheckConstraints(SystemClass system, SystemSchedule proposedSchedule, Constraint constraint) { // pass the state for checking if (!constraint.Accepts(proposedSchedule.AllStates.GetLastState())) { Logger.Report("Constraint Failed: " + constraint.GetType().ToString()); return(false); } return(true); }
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)); * } */ }
public override double Evaluate(SystemSchedule schedule) { double sum = 0; foreach (Event eit in schedule.AllStates.Events) { foreach (KeyValuePair <Asset, Task> assetTask in eit.Tasks) { Task task = assetTask.Value; sum += 5 - task.Target.Value; if (task.Type == TaskType.COMM) { sum += (double)Dependencies.getDependencyFunc("EvalfromSSDR").DynamicInvoke(eit); } } } return(sum); }
public SystemSchedule(SystemSchedule oldSchedule, List <Task> newTaskList, double newTaskStartTime) { int i = 0; //need a double iterator foreach (AssetSchedule asIt in oldSchedule.AssetScheds) { Task tIt = newTaskList[i]; if (tIt == null) { Event eventToAdd = new Event(tIt, new SystemState(asIt.getLastState(), newTaskStartTime)); AssetScheds.Add(new AssetSchedule(asIt, eventToAdd)); //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 <AssetSchedule>(asIt)); } i++; } }
/// <summary> /// Method to check if the subsystem can perform the most recent task that was added to the schedule /// </summary> /// <param name="subsystem"></param> /// <param name="proposedSchedule"></param> /// <param name="environment"></param> /// <returns></returns> private static bool checkSub(Subsystem subsystem, SystemSchedule proposedSchedule, Universe environment) { if (subsystem.IsEvaluated) { return(true); } var events = proposedSchedule.AllStates.Events; if (events.Count != 0) { //if (events.Count > 1) // subsystem._oldState = events.ElementAt(events.Count - 2).State; //else // subsystem._oldState = null; if (!subsystem.CanPerform(events.Peek(), environment)) { return(false); } events.Peek().isEvaluated += 1; } return(true); }
/// <summary> /// Remove Schedules with the worst scores from the List of SystemSchedules so that there are only _maxNumSchedules. /// </summary> /// <param name="schedulesToCrop"></param> /// <param name="scheduleEvaluator"></param> /// <param name="emptySched"></param> void CropSchedules(List <SystemSchedule> schedulesToCrop, Evaluator scheduleEvaluator, SystemSchedule emptySched) { // Evaluate the schedules and set their values foreach (SystemSchedule systemSchedule in schedulesToCrop) { systemSchedule.ScheduleValue = scheduleEvaluator.Evaluate(systemSchedule); } // Sort the sysScheds by their values schedulesToCrop.Sort((x, y) => x.ScheduleValue.CompareTo(y.ScheduleValue)); // schedulesToCrop.ToList(); // Delete the sysScheds that don't fit int j = 0; int numSched = schedulesToCrop.Count; for (int i = numSched - 1; j < numSched - _maxNumSchedules; i--) { if (schedulesToCrop[i] != emptySched) { schedulesToCrop.Remove(schedulesToCrop[i]); j++; } } }
public virtual List <SystemSchedule> GenerateSchedules(SystemClass system, Stack <MissionElements.Task> tasks, SystemState initialStateList, Evaluator scheduleEvaluator) { //system.setThreadNum(1); //DWORD startTickCount = GetTickCount(); //accumSchedTimeMs = 0; // get the global dependencies object //Dependencies dependencies = new Dependencies().Instance(); Console.WriteLine("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) { Console.Write("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 Console.WriteLine(" DONE!"); } // otherwise generate an exhaustive list of possibilities for assetTaskList else { Console.Write("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)); } exhaustive.Push(allAccesses); allAccesses.Clear(); } scheduleCombos = (Stack <Stack <Access> >)exhaustive.CartesianProduct(); Console.WriteLine(" DONE!"); } /// \todo 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(); for (double currentTime = _startTime; currentTime < _endTime; currentTime += _stepLength) { Console.WriteLine(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) { CropSchedules(systemSchedules, scheduleEvaluator, emptySchedule); } // Create a new system schedule list by adding each of the new Task commands for the Assets onto each of the old schedules // Start timing // Generate an exhaustive list of new tasks possible from the combinations of Assets and Tasks //TODO: Parallelize this. List <SystemSchedule> potentialSystemSchedules = new List <SystemSchedule>(); foreach (var oldSystemSchedule in systemSchedules) { foreach (var newAccessStack in scheduleCombos) { if (oldSystemSchedule.CanAddTasks(newAccessStack, currentTime)) { SystemSchedule newSched = new SystemSchedule(oldSystemSchedule, newAccessStack, currentTime); potentialSystemSchedules.Add(newSched); } } potentialSystemSchedules.Add(new SystemSchedule(oldSystemSchedule)); //deep copy } // TODO EAM: Remove this and only add new SystemScedule if canAddTasks and CanPerform are both true. That way we don't need to delete SystemSchedules after the fact below. List <SystemSchedule> systemCanPerformList = new List <SystemSchedule>(); //for (list<systemSchedule*>::iterator newSchedIt = newSysScheds.begin(); newSchedIt != newSysScheds.end(); newSchedIt++) // The parallel version // Should we use a Partitioner? // Need to test this... /* * Stopwatch stopWatch = new Stopwatch(); * stopWatch.Start(); * // The Scheduler has to call the CanPerform for a SystemClass, SystemSchedule combo. The SystemClass * Parallel.ForEach(potentialSystemSchedules, (currentSchedule) => * { * // dependencies.updateStates(newSchedule.getEndStates()); * if (Checker.CheckSchedule(system, currentSchedule)) * systemCanPerformList.Add(currentSchedule); * Console.WriteLine("Processing {0} on thread {1}", currentSchedule.ToString(), Thread.CurrentThread.ManagedThreadId); * }); * stopWatch.Stop(); * * TimeSpan ts = stopWatch.Elapsed; * // Format and display the TimeSpan value. * string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", * ts.Hours, ts.Minutes, ts.Seconds, * ts.Milliseconds / 10); * Console.WriteLine("Parallel Scheduler RunTime: " + elapsedTime); */ foreach (var potentialSchedule in potentialSystemSchedules) { if (Checker.CheckSchedule(system, potentialSchedule)) { systemCanPerformList.Add(potentialSchedule); } //dependencies.updateStates(newSchedule.getEndStates()); //systemCanPerformList.Push(system.canPerform(potentialSchedule)); } // End timing /* * // delete systemSchedules (and corresponding lower level classes) that are not possible * list<systemSchedule*>::iterator eraseIt = newSysScheds.begin(); * for (vector<bool>::iterator successIt = systemCanPerformList.begin(); successIt != systemCanPerformList.end(); successIt++) * { * if (*successIt) { eraseIt++; } * else { * delete* eraseIt; * eraseIt = newSysScheds.erase(eraseIt); * } * } */ // Merge old and new systemSchedules systemSchedules.InsertRange(0, systemCanPerformList);//<--This was potentialSystemSchedules potentialSystemSchedules.Clear(); // Print completion percentage in command window Console.Write("Scheduler Status: {0} done; {1} schedules generated.", 100 * currentTime / _endTime, systemSchedules.Count); } if (systemSchedules.Count > _maxNumSchedules) { CropSchedules(systemSchedules, scheduleEvaluator, emptySchedule); } // THIS GOES AWAY IF CAN EXTEND HAPPENS IN THE SUBSYSTEM - EAM // extend all schedules to the end of the simulation /* * foreach (var schedule in systemSchedules) * { * bool canExtendUntilEnd = true; * // Iterate through Subsystem Nodes and set that they havent run * foreach (var subsystem in system.Subsystems) * subsystem.IsEvaluated = false; * * int subAssetNum; * foreach (var subsystem in system.Subsystems) * canExtendUntilEnd &= subsystem.canPerform(schedule.getSubsystemNewState(subsystem.Asset), schedule.getSubsytemNewTask(subsystem.Asset), system.Environment, _endTime, true); * * // Iterate through constraints * foreach (var constraint in system.Constraints) * { * canExtendUntilEnd &= constraint.Accepts(schedule); * } * // for (vector <const Constraint*>::const_iterator constraintIt = system.getConstraints().begin(); constraintIt != system.getConstraints().end(); constraintIt++) * // canExtendUntilEnd &= (*constraintIt)->accepts(*schedIt); * if (!canExtendUntilEnd) { * //delete *schedIt; * Console.WriteLine("Schedule may not be valid"); * } * } */ //DWORD endSchedTickCount = GetTickCount(); //schedTimeMs = endSchedTickCount - startSchedTickCount; //DWORD endTickCount = GetTickCount(); //totalTimeMs = endTickCount - startTickCount; return(systemSchedules); }
public SystemSchedule(SystemSchedule oldSchedule, Event emptyEvent) { AllStates = new StateHistory(oldSchedule.AllStates); AllStates.Events.Push(emptyEvent); }
/// <summary> /// Utilitiy method to write the schedule to csv file /// </summary> /// <param name="schedule"></param> /// <param name="scheduleWritePath"></param> public static void WriteSchedule(SystemSchedule schedule, String scheduleWritePath) { var csv = new StringBuilder(); Dictionary <StateVarKey <double>, SortedList <double, double> > stateTimeDData = new Dictionary <StateVarKey <double>, SortedList <double, double> >(); Dictionary <StateVarKey <int>, SortedList <double, int> > stateTimeIData = new Dictionary <StateVarKey <int>, SortedList <double, int> >(); Dictionary <StateVarKey <int>, SortedList <double, int> > stateTimeBData = new Dictionary <StateVarKey <int>, SortedList <double, int> >(); // need 0s and 1 for matlab to read in csv Dictionary <StateVarKey <Matrix <double> >, SortedList <double, Matrix <double> > > stateTimeMData = new Dictionary <StateVarKey <Matrix <double> >, SortedList <double, Matrix <double> > >(); string stateTimeData = "Time,"; string stateData = ""; csv.Clear(); SystemState sysState = schedule.AllStates.Events.Peek().State; while (sysState != null) { foreach (var kvpDoubleProfile in sysState.Ddata) { foreach (var data in kvpDoubleProfile.Value.Data) { if (!stateTimeDData.ContainsKey(kvpDoubleProfile.Key)) { var lt = new SortedList <double, double>(); lt.Add(data.Key, data.Value); stateTimeDData.Add(kvpDoubleProfile.Key, lt); } else if (!stateTimeDData[kvpDoubleProfile.Key].ContainsKey(data.Key)) { stateTimeDData[kvpDoubleProfile.Key].Add(data.Key, data.Value); } else { Console.WriteLine("idk"); } } } foreach (var kvpIntProfile in sysState.Idata) { foreach (var data in kvpIntProfile.Value.Data) { if (!stateTimeIData.ContainsKey(kvpIntProfile.Key)) { var lt = new SortedList <double, int>(); lt.Add(data.Key, data.Value); stateTimeIData.Add(kvpIntProfile.Key, lt); } else if (!stateTimeIData[kvpIntProfile.Key].ContainsKey(data.Key)) { stateTimeIData[kvpIntProfile.Key].Add(data.Key, data.Value); } } } foreach (var kvpBoolProfile in sysState.Bdata) { foreach (var data in kvpBoolProfile.Value.Data) { if (!stateTimeBData.ContainsKey(kvpBoolProfile.Key)) { var lt = new SortedList <double, int>(); lt.Add(data.Key, (data.Value ? 1 : 0)); //convert to int for matlab to read in for csv stateTimeBData.Add((StateVarKey <int>)kvpBoolProfile.Key, lt); } else if (!stateTimeBData[kvpBoolProfile.Key].ContainsKey(data.Key)) { stateTimeBData[(StateVarKey <int>)kvpBoolProfile.Key].Add(data.Key, data.Value ? 1 : 0); } } } foreach (var kvpMatrixProfile in sysState.Mdata) { foreach (var data in kvpMatrixProfile.Value.Data) { if (!stateTimeMData.ContainsKey(kvpMatrixProfile.Key)) { var lt = new SortedList <double, Matrix <double> >(); lt.Add(data.Key, data.Value); stateTimeMData.Add(kvpMatrixProfile.Key, lt); } else if (!stateTimeMData[kvpMatrixProfile.Key].ContainsKey(data.Key)) { stateTimeMData[kvpMatrixProfile.Key].Add(data.Key, data.Value); } } } sysState = sysState.Previous; } System.IO.Directory.CreateDirectory(scheduleWritePath); foreach (var list in stateTimeDData) { writeStateVariable(list, scheduleWritePath); } foreach (var list in stateTimeIData) { writeStateVariable(list, scheduleWritePath); } foreach (var list in stateTimeBData) { writeStateVariable(list, scheduleWritePath); } foreach (var list in stateTimeMData) { writeStateVariable(list, scheduleWritePath); } }
/// <summary> /// Determine if the first schedule value is greater than the second /// </summary> /// <param name="elem1"></param> /// <param name="elem2"></param> /// <returns></returns> bool SchedGreater(SystemSchedule elem1, SystemSchedule elem2) { return(elem1.ScheduleValue > elem2.ScheduleValue); }
/// <summary> /// Remove Schedules with the worst scores from the List of SystemSchedules so that there are only _maxNumSchedules. /// </summary> /// <param name="schedulesToCrop"></param> /// <param name="scheduleEvaluator"></param> /// <param name="emptySched"></param> public void CropSchedules(List <SystemSchedule> schedulesToCrop, Evaluator scheduleEvaluator, SystemSchedule emptySched) { // Evaluate the schedules and set their values foreach (SystemSchedule systemSchedule in schedulesToCrop) { systemSchedule.ScheduleValue = scheduleEvaluator.Evaluate(systemSchedule); } // Sort the sysScheds by their values schedulesToCrop.Sort((x, y) => x.ScheduleValue.CompareTo(y.ScheduleValue)); // Delete the sysScheds that don't fit int numSched = schedulesToCrop.Count; for (int i = 0; i < numSched - _numSchedCropTo; i++) { schedulesToCrop.Remove(schedulesToCrop[0]); } schedulesToCrop.TrimExcess(); }
/// <summary> /// Anstract class that analyzes the given schedule and assigns a value to it. /// </summary> /// <param name="schedule"></param> /// <returns></returns> public abstract double Evaluate(SystemSchedule schedule);
/// <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 " + 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); }
/// <summary> /// Implementation of the evaluate method /// </summary> /// <param name="schedule"></param> /// <returns></returns> public override double Evaluate(SystemSchedule schedule) { dynamic eval = _pythonInstance.Evaluate(schedule); return((double)eval); }