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