public void LoadSubsystems()
{
// Find the main model node from the XML model input file
var modelInputXMLNode = XmlParser.GetModelNode(modelInputFilePath);
// Set up Subsystem Nodes, first loop through the assets in the XML model input file
foreach (XmlNode modelChildNode in modelInputXMLNode.ChildNodes)
{
if (modelChildNode.Name.Equals("ENVIRONMENT"))
{
// Create the Environment based on the XMLNode
SystemUniverse = UniverseFactory.GetUniverseClass(modelChildNode);
}
else if (SystemUniverse == null)
{
SystemUniverse = new SpaceEnvironment();
}
if (modelChildNode.Name.Equals("ASSET"))
{
Asset asset = new Asset(modelChildNode);
asset.AssetDynamicState.Eoms.SetEnvironment(SystemUniverse);
assetList.Add(asset);
// Loop through all the of the ChildNodess for this Asset
foreach (XmlNode childNode in modelChildNode.ChildNodes)
{
// Get the current Subsystem XML Node, and create it using the SubsystemFactory
if (childNode.Name.Equals("SUBSYSTEM"))
{ //is this how we want to do this?
// Check if the type of the Subsystem is scripted, networked, or other
string subName = SubsystemFactory.GetSubsystem(childNode, dependencies, asset, subsystemMap);
foreach (XmlNode ICorDepNode in childNode.ChildNodes)
{
if (ICorDepNode.Name.Equals("IC"))
{
ICNodes.Add(ICorDepNode);
}
if (ICorDepNode.Name.Equals("DEPENDENCY"))
{
string depSubName = "", depFunc = "";
depSubName = Subsystem.parseNameFromXmlNode(ICorDepNode, asset.Name);
dependencyMap.Add(new KeyValuePair <string, string>(subName, depSubName));
if (ICorDepNode.Attributes["fcnName"] != null)
{
depFunc = ICorDepNode.Attributes["fcnName"].Value.ToString();
dependencyFcnMap.Add(new KeyValuePair <string, string>(subName, depFunc));
}
}
}
}
//Create a new Constraint
if (childNode.Name.Equals("CONSTRAINT"))
{
constraintsList.Add(ConstraintFactory.GetConstraint(childNode, subsystemMap, asset));
}
}
if (ICNodes.Count > 0)
{
initialSysState.Add(SystemState.setInitialSystemState(ICNodes, asset));
}
ICNodes.Clear();
}
}
foreach (KeyValuePair <string, Subsystem> sub in subsystemMap)
{
if (!sub.Value.GetType().Equals(typeof(ScriptedSubsystem)))//let the scripted subsystems add their own dependency collector
{
sub.Value.AddDependencyCollector();
}
subList.Add(sub.Value);
}
log.Info("Subsystems and Constraints Loaded");
}
/// <summary>
/// KarveToolBarViewModel is a view model to modle the toolbar behaviour.
/// </summary>
/// <param name="dataServices">Service for fetching datas</param>
/// <param name="eventManager">Service for communicate with other view models</param>
/// <param name="careKeeper">Service for caring command and storing/undoing command</param>
/// <param name="regionManager">Service for region handling</param>
/// <param name="dialogService">Service for spotting the dialog</param>
/// <param name="configurationService">Service for the configuraration parameters</param>
public KarveToolBarViewModel(IDataServices dataServices,
IEventManager eventManager,
ICareKeeperService careKeeper,
IRegionManager regionManager,
IDialogService dialogService,
IConfigurationService configurationService) : base(dataServices, null, dialogService, configurationService)
{
this._dictionary = SubsystemFactory.GetSubsytem();
this._dataServices = dataServices;
this._dialogService = dialogService;
this._configurationService = configurationService;
this._eventManager = eventManager;
this._eventManager.RegisterObserverToolBar(this);
this._careKeeper = careKeeper;
this.SaveCommand = new DelegateCommand(DoSaveCommand);
this.NewCommand = new DelegateCommand(DoNewCommand);
this.DeleteCommand = new DelegateCommand <object>(DoDeleteCommand);
this._dataServices = dataServices;
this._configurationService = configurationService;
this._eventManager = eventManager;
this._eventManager.RegisterObserverToolBar(this);
this.CurrentSaveImagePath = currentSaveImage;
_regionManager = regionManager;
_states = ToolbarStates.None;
_noActiveValue = string.Empty;
this.IsSaveEnabled = false;
this.IsDeleteEnabled = false;
this.IsNewEnabled = false;
ConfirmationRequest = new InteractionRequest <IConfirmation>();
Confirmation request = new Confirmation
{
Title = "Confirmacion",
Content = confirmDelete
};
ViewModelUri = new Uri("karve://toolbar/viewmodel?id=" + UniqueId);
ConfirmationCommand = new DelegateCommand(() =>
{
// string noActiveValue = configurationService.GetPrimaryKeyValue();
request.Content = confirmDelete;
ConfirmationRequest.Raise(request);
if (request.Confirmed)
{
string value = string.Empty;
var singleView = _regionManager.Regions[RegionNames.TabRegion].ActiveViews.FirstOrDefault();
if (singleView != null)
{
var headerProp = singleView.GetType().GetProperty("Header");
if (headerProp != null)
{
if (headerProp.GetValue(singleView) is string header)
{
value = header.Split('.')[0];
}
}
}
DeleteCommand.Execute(value);
}
});
SaveValueCommand = new DelegateCommand(() =>
{
request.Content = confirmSave;
ConfirmationRequest.Raise(request);
if (request.Confirmed)
{
SaveCommand.Execute();
}
else
{
this.CurrentSaveImagePath = KarveToolBarViewModel.currentSaveImage;
}
});
AddValidationChain();
_uniqueId = ObserverName + Guid.NewGuid();
}
public void GenerateSchedulesUnitTest()
{
// Get the input filenames
//string simulationInputFilePath = args[1];
//string targetDeckFilePath = args[2];
//string modelInputFileName = args[3];
//string outputPath = args[4];
var simulationInputFilePath = @"..\..\..\SimulationInput.XML"; // @"C:\Users\admin\Documents\Visual Studio 2015\Projects\Horizon-Simulation-Framework\Horizon_v2_3\io\SimulationInput.XML";
var targetDeckFilePath = @"..\..\..\v2.2-300targets.xml";
var modelInputFilePath = @"..\..\..\Model_Static.xml";
// Initialize critical section for dependencies ??Morgan Doesn't know what this does
// InitializeCriticalSection(&horizon::sub::dep::NodeDependencies::cs);
// Find the main input node from the XML input files
var XmlDoc = new XmlDocument();
XmlDoc.Load(simulationInputFilePath);
XmlNodeList simulationInputXMLNodeList = XmlDoc.GetElementsByTagName("SCENARIO");
var XmlEnum = simulationInputXMLNodeList.GetEnumerator();
XmlEnum.MoveNext();
var simulationInputXMLNode = (XmlNode)XmlEnum.Current;
var scenarioName = simulationInputXMLNode.Attributes["scenarioName"].InnerXml;
Console.Write("EXECUITING SCENARIO: ");
Console.WriteLine(scenarioName);
// Load the simulation parameters from the XML simulation input file
XmlNode simParametersXMLNode = simulationInputXMLNode["SIMULATION_PARAMETERS"];
bool simParamsLoaded = SimParameters.LoadSimParameters(simParametersXMLNode, scenarioName);
// Load the scheduler parameters defined in the XML simulation input file
XmlNode schedParametersXMLNode = simulationInputXMLNode["SCHEDULER_PARAMETERS"];
//Scheduler systemScheduler = new Scheduler();
//bool schedParamsLoaded = loadSchedulerParams(schedParametersXMLNode, systemScheduler);
bool paramsLoaded = SchedParameters.LoadSchedParameters(schedParametersXMLNode);
Scheduler systemScheduler = new Scheduler();
//MultiThreadedScheduler* systemScheduler = new MultiThreadedScheduler;
// Load the target deck into the targets list from the XML target deck input file
//var XmlDoc = new XmlDocument();
XmlDoc.Load(targetDeckFilePath);
XmlNodeList targetDeckXMLNodeList = XmlDoc.GetElementsByTagName("TARGETDECK");
int numTargets = XmlDoc.GetElementsByTagName("TARGET").Count;
XmlEnum = targetDeckXMLNodeList.GetEnumerator();
XmlEnum.MoveNext();
var targetDeckXMLNode = (XmlNode)XmlEnum.Current;
Stack <Task> systemTasks = new Stack <Task>();
bool targetsLoaded = Task.loadTargetsIntoTaskList(targetDeckXMLNode, systemTasks);
Console.WriteLine("Initial states set");
// Find the main model node from the XML model input file
XmlDoc.Load(modelInputFilePath);
XmlNodeList modelXMLNodeList = XmlDoc.GetElementsByTagName("MODEL");
XmlEnum = modelXMLNodeList.GetEnumerator();
XmlEnum.MoveNext();
var modelInputXMLNode = (XmlNode)XmlEnum.Current;
// Load the environment. First check if there is an ENVIRONMENT XMLNode in the input file
Universe SystemUniverse = null;
foreach (XmlNode node in modelInputXMLNode.ChildNodes)
{
if (node.Attributes["ENVIRONMENT"] != null)
{
// Create the Environment based on the XMLNode
SystemUniverse = new Universe(node);
}
}
if (SystemUniverse == null)
{
SystemUniverse = new Universe();
}
//Create singleton dependency dictionary
Dependencies dependencies = Dependencies.Instance;
// Initialize List to hold assets and subsystem nodes
List <Asset> assetList = new List <Asset>();
List <Subsystem> subNodeList = new List <Subsystem>();
// Maps used to set up preceeding nodes
Dictionary <ISubsystem, XmlNode> subsystemXMLNodeMap = new Dictionary <ISubsystem, XmlNode>();
Dictionary <string, Subsystem> subsystemMap = new Dictionary <string, Subsystem>();
List <KeyValuePair <string, string> > dependencyMap = new List <KeyValuePair <string, string> >();
List <KeyValuePair <string, string> > dependencyFcnMap = new List <KeyValuePair <string, string> >();
// Dictionary<string, ScriptedSubsystem> scriptedSubNames = new Dictionary<string, ScriptedSubsystem>();
// Create Constraint list
List <Constraint> constraintsList = new List <Constraint>();
//Create Lists to hold all the initial condition and dependency nodes to be parsed later
List <XmlNode> ICNodes = new List <XmlNode>();
List <XmlNode> DepNodes = new List <XmlNode>();
SystemState initialSysState = new SystemState();
// Enable Python scripting support, add additional functions defined in input file
bool enableScripting = false;
// Set up Subsystem Nodes, first loop through the assets in the XML model input file
foreach (XmlNode childNodeAsset in modelInputXMLNode.ChildNodes)
{
if (childNodeAsset.Name.Equals("PYTHON"))
{
if (childNodeAsset.Attributes["enableScripting"] != null)
{
if (childNodeAsset.Attributes["enableScripting"].Value.ToString().ToLower().Equals("true"))
{
enableScripting = true;
}
}
// Loop through all the of the file nodes -- TODO (Morgan) What other types of things might be scripted
foreach (XmlNode fileXmlNode in childNodeAsset.ChildNodes)
{
// If scripting is enabled, parse the script file designated by the attribute
if (enableScripting)
{
// Parse script file if the attribute exists
if (fileXmlNode.ChildNodes[0].Name.Equals("EOMS_FILE"))
{
string fileName = fileXmlNode.ChildNodes[0].Attributes["src"].Value.ToString();
ScriptedEOMS eoms = new ScriptedEOMS(fileName);
}
}
}
}
if (childNodeAsset.Name.Equals("ASSET"))
{
Asset asset = new Asset(childNodeAsset);
assetList.Add(asset);
// Loop through all the of the ChildNodess for this Asset
foreach (XmlNode childNode in childNodeAsset.ChildNodes)
{
// Get the current Subsystem XML Node, and create it using the SubsystemFactory
if (childNode.Name.Equals("SUBSYSTEM"))
{ //is this how we want to do this?
// Check if the type of the Subsystem is scripted, networked, or other
string subName = SubsystemFactory.GetSubsystem(childNode, enableScripting, dependencies, asset, subsystemMap);
foreach (XmlNode ICorDepNode in childNode.ChildNodes)
{
if (ICorDepNode.Name.Equals("IC"))
{
ICNodes.Add(ICorDepNode);
}
if (ICorDepNode.Name.Equals("DEPENDENCY"))
{
string depSubName = "", depFunc = "";
if (ICorDepNode.Attributes["subsystemName"] != null)
{
depSubName = ICorDepNode.Attributes["subsystemName"].Value.ToString();
}
else
{
throw new MissingMemberException("Missing subsystem name in " + asset.Name);
}
dependencyMap.Add(new KeyValuePair <string, string>(subName, depSubName));
if (ICorDepNode.Attributes["fcnName"] != null)
{
depFunc = ICorDepNode.Attributes["fcnName"].Value.ToString();
}
else
{
throw new MissingMemberException("Missing dependency function for subsystem" + subName);
}
dependencyFcnMap.Add(new KeyValuePair <string, string>(subName, depFunc));
}
// if (ICorDepNode.Name.Equals("DEPENDENCY_FCN"))
// dependencyFcnMap.Add(childNode.Attributes["subsystemName"].Value.ToString(), ICorDepNode.Attributes["fcnName"].Value.ToString());
}
//Parse the initial condition nodes
}
//Create a new Constraint
if (childNode.Name.Equals("CONSTRAINT"))
{
//Constraint factory isnt made yet
//constraintsList.Add(ConstraintFactory.getConstraint(childNode));
//Subsystem constrainedSub;
//subsystemMap.TryGetValue(childNode.Attributes["subsystemName"].Value.ToString(), out constrainedSub);
//constraintsList.Last().AddConstrainedSub(constrainedSub);
}
}
if (ICNodes.Count > 0)
{
initialSysState.Add(SystemState.setInitialSystemState(ICNodes, asset));
}
ICNodes.Clear();
}
}
//Add all the dependent subsystems to tge dependent subsystem list of the subsystems
foreach (KeyValuePair <string, string> depSubPair in dependencyMap)
{
Subsystem subToAddDep, depSub;
subsystemMap.TryGetValue(depSubPair.Key, out subToAddDep);
subsystemMap.TryGetValue(depSubPair.Value, out depSub);
subToAddDep.DependentSubsystems.Add(depSub);
}
//give the dependency functions to all the subsytems that need them
foreach (KeyValuePair <string, string> depFunc in dependencyFcnMap)
{
Subsystem subToAddDep;
subsystemMap.TryGetValue(depFunc.Key, out subToAddDep);
subToAddDep.SubsystemDependencyFunctions.Add(depFunc.Value, dependencies.getDependencyFunc(depFunc.Value));
}
Console.WriteLine("Dependencies Loaded");
List <Constraint> constraintList = new List <Constraint>();
SystemClass system = new SystemClass(assetList, subNodeList, constraintList, SystemUniverse);
TargetValueEvaluator scheduleEvaluator = new TargetValueEvaluator(dependencies);
systemScheduler.GenerateSchedules(system, systemTasks, initialSysState, scheduleEvaluator);
}
static void Main(string[] args)
{
// Get the input filenames
//string simulationInputFilePath = args[1];
//string targetDeckFilePath = args[2];
//string modelInputFileName = args[3];
//string outputPath = args[4];
var simulationInputFilePath = @"..\..\..\SimulationInput.XML"; // @"C:\Users\admin\Documents\Visual Studio 2015\Projects\Horizon-Simulation-Framework\Horizon_v2_3\io\SimulationInput.XML";
var targetDeckFilePath = @"..\..\..\v2.2-300targets.xml";
var modelInputFilePath = @"..\..\..\Model_Static.xml";
var outputPath = String.Format("..\\..\\..\\output-{0:yyyy-MM-dd}-0", DateTime.Now);
//Need to figure out output data versioning
//if (File.Exists(outputPath + ".txt"))
//{
// var version = outputPath[outputPath.Length - 1];
// int number = (int)Convert.ChangeType(version, typeof(int))+1;
// outputPath.Remove(outputPath.Length - 1);
// outputPath += number;
//}
outputPath += ".txt";
// Find the main input node from the XML input files
var XmlDoc = new XmlDocument();
XmlDoc.Load(simulationInputFilePath);
XmlNodeList simulationInputXMLNodeList = XmlDoc.GetElementsByTagName("SCENARIO");
var XmlEnum = simulationInputXMLNodeList.GetEnumerator();
XmlEnum.MoveNext();
var simulationInputXMLNode = (XmlNode)XmlEnum.Current;
var scenarioName = simulationInputXMLNode.Attributes["scenarioName"].InnerXml;
Console.Write("EXECUITING SCENARIO: ");
Console.WriteLine(scenarioName);
// Load the simulation parameters from the XML simulation input file
XmlNode simParametersXMLNode = simulationInputXMLNode["SIMULATION_PARAMETERS"];
bool simParamsLoaded = SimParameters.LoadSimParameters(simParametersXMLNode, scenarioName);
// Load the scheduler parameters defined in the XML simulation input file
XmlNode schedParametersXMLNode = simulationInputXMLNode["SCHEDULER_PARAMETERS"];
bool paramsLoaded = SchedParameters.LoadSchedParameters(schedParametersXMLNode);
Scheduler systemScheduler = new Scheduler();
//MultiThreadedScheduler systemScheduler = new MultiThreadedScheduler();
// Load the target deck into the targets list from the XML target deck input file
XmlDoc.Load(targetDeckFilePath);
XmlNodeList targetDeckXMLNodeList = XmlDoc.GetElementsByTagName("TARGETDECK");
int numTargets = XmlDoc.GetElementsByTagName("TARGET").Count;
XmlEnum = targetDeckXMLNodeList.GetEnumerator();
XmlEnum.MoveNext();
var targetDeckXMLNode = (XmlNode)XmlEnum.Current;
Stack <Task> systemTasks = new Stack <Task>();
bool targetsLoaded = Task.loadTargetsIntoTaskList(targetDeckXMLNode, systemTasks);
Console.WriteLine("Initial states set");
// Find the main model node from the XML model input file
XmlDoc.Load(modelInputFilePath);
XmlNodeList modelXMLNodeList = XmlDoc.GetElementsByTagName("MODEL");
XmlEnum = modelXMLNodeList.GetEnumerator();
XmlEnum.MoveNext();
var modelInputXMLNode = (XmlNode)XmlEnum.Current;
// Load the environment. First check if there is an ENVIRONMENT XMLNode in the input file
Universe SystemUniverse = null;
foreach (XmlNode node in modelInputXMLNode.ChildNodes)
{
if (node.Attributes["ENVIRONMENT"] != null)
{
// Create the Environment based on the XMLNode
SystemUniverse = new Universe(node);
}
}
if (SystemUniverse == null)
{
SystemUniverse = new Universe();
}
//Create singleton dependency dictionary
Dependencies dependencies = Dependencies.Instance;
// Initialize List to hold assets and subsystem nodes
List <Asset> assetList = new List <Asset>();
List <Subsystem> subList = new List <Subsystem>();
// Maps used to set up preceeding nodes
Dictionary <ISubsystem, XmlNode> subsystemXMLNodeMap = new Dictionary <ISubsystem, XmlNode>();
Dictionary <string, Subsystem> subsystemMap = new Dictionary <string, Subsystem>();
List <KeyValuePair <string, string> > dependencyMap = new List <KeyValuePair <string, string> >();
List <KeyValuePair <string, string> > dependencyFcnMap = new List <KeyValuePair <string, string> >();
// Dictionary<string, ScriptedSubsystem> scriptedSubNames = new Dictionary<string, ScriptedSubsystem>();
// Create Constraint list
List <Constraint> constraintsList = new List <Constraint>();
//Create Lists to hold all the initial condition and dependency nodes to be parsed later
List <XmlNode> ICNodes = new List <XmlNode>();
List <XmlNode> DepNodes = new List <XmlNode>();
SystemState initialSysState = new SystemState();
// Enable Python scripting support, add additional functions defined in input file
bool enableScripting = false;
// Set up Subsystem Nodes, first loop through the assets in the XML model input file
foreach (XmlNode childNodeAsset in modelInputXMLNode.ChildNodes)
{
if (childNodeAsset.Name.Equals("PYTHON"))
{
if (childNodeAsset.Attributes["enableScripting"] != null)
{
if (childNodeAsset.Attributes["enableScripting"].Value.ToString().ToLower().Equals("true"))
{
enableScripting = true;
}
}
// Loop through all the of the file nodes -- TODO (Morgan) What other types of things might be scripted
foreach (XmlNode fileXmlNode in childNodeAsset.ChildNodes)
{
// If scripting is enabled, parse the script file designated by the attribute
if (enableScripting)
{
// Parse script file if the attribute exists
if (fileXmlNode.ChildNodes[0].Name.Equals("EOMS_FILE"))
{
string fileName = fileXmlNode.ChildNodes[0].Attributes["src"].Value.ToString();
ScriptedEOMS eoms = new ScriptedEOMS(fileName);
}
}
}
}
if (childNodeAsset.Name.Equals("ASSET"))
{
Asset asset = new Asset(childNodeAsset);
assetList.Add(asset);
// Loop through all the of the ChildNodess for this Asset
foreach (XmlNode childNode in childNodeAsset.ChildNodes)
{
// Get the current Subsystem XML Node, and create it using the SubsystemFactory
if (childNode.Name.Equals("SUBSYSTEM"))
{ //is this how we want to do this?
// Check if the type of the Subsystem is scripted, networked, or other
string subName = SubsystemFactory.GetSubsystem(childNode, enableScripting, dependencies, asset, subsystemMap);
foreach (XmlNode ICorDepNode in childNode.ChildNodes)
{
if (ICorDepNode.Name.Equals("IC"))
{
ICNodes.Add(ICorDepNode);
}
if (ICorDepNode.Name.Equals("DEPENDENCY"))
{
string depSubName = "", depFunc = "";
depSubName = Subsystem.parseNameFromXmlNode(ICorDepNode, asset.Name);
dependencyMap.Add(new KeyValuePair <string, string>(subName, depSubName));
if (ICorDepNode.Attributes["fcnName"] != null)
{
depFunc = ICorDepNode.Attributes["fcnName"].Value.ToString();
dependencyFcnMap.Add(new KeyValuePair <string, string>(subName, depFunc));
}
}
}
}
//Create a new Constraint
if (childNode.Name.Equals("CONSTRAINT"))
{
constraintsList.Add(ConstraintFactory.getConstraint(childNode, subsystemMap, asset));
}
}
if (ICNodes.Count > 0)
{
initialSysState.Add(SystemState.setInitialSystemState(ICNodes, asset));
}
ICNodes.Clear();
}
}
foreach (KeyValuePair <string, Subsystem> sub in subsystemMap)
{
subList.Add(sub.Value);
}
Console.WriteLine("Subsystems and Constraints Loaded");
//Add all the dependent subsystems to the dependent subsystem list of the subsystems
foreach (KeyValuePair <string, string> depSubPair in dependencyMap)
{
Subsystem subToAddDep, depSub;
subsystemMap.TryGetValue(depSubPair.Key, out subToAddDep);
subsystemMap.TryGetValue(depSubPair.Value, out depSub);
subToAddDep.DependentSubsystems.Add(depSub);
}
//give the dependency functions to all the subsytems that need them
foreach (KeyValuePair <string, string> depFunc in dependencyFcnMap)
{
Subsystem subToAddDep;
subsystemMap.TryGetValue(depFunc.Key, out subToAddDep);
subToAddDep.SubsystemDependencyFunctions.Add(depFunc.Value, dependencies.getDependencyFunc(depFunc.Value));
}
Console.WriteLine("Dependencies Loaded");
//Need to make this parse Xml
Evaluator schedEvaluator = new TargetValueEvaluator(dependencies);
SystemClass simSystem = new SystemClass(assetList, subList, constraintsList, SystemUniverse);
if (simSystem.checkForCircularDependencies())
{
throw new NotFiniteNumberException("System has circular dependencies! Please correct then try again.");
}
Scheduler scheduler = new Scheduler();
List <SystemSchedule> schedules = scheduler.GenerateSchedules(simSystem, systemTasks, initialSysState, schedEvaluator);
double maxSched = 0;
int i = 0;
using (StreamWriter sw = File.CreateText(outputPath))
{
foreach (SystemSchedule sched in schedules)
{
sw.WriteLine("Schedule Number: " + i);
foreach (var eit in sched.AllStates.Events)
{
if (eit.Tasks.Values.GetType().Equals(TaskType.COMM))
{
Console.WriteLine("Schedule {0} contains Comm task", i);
}
if (i < 5)
{ //just compare the first 5 schedules for now
sw.WriteLine(eit.ToString());
}
}
if (sched.ScheduleValue > maxSched)
{
maxSched = sched.ScheduleValue;
}
i++;
}
Console.WriteLine(maxSched);
}
Console.ReadKey();
// *********************************Output selected data*************************************
// bool schedOutput = dataOut.writeAll(schedules, simSystem);
// ******************************************************************************************
}
static int Main(string[] args)
{
// Begin the Logger
ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
log.Info("STARTING HSF RUN"); //Do not delete
// Set Defaults
var simulationInputFilePath = @"..\..\..\SimulationInput.XML";
var targetDeckFilePath = @"..\..\..\v2.2-300targets.xml";
var modelInputFilePath = @"..\..\..\DSAC_Static.xml";
bool simulationSet = false, targetSet = false, modelSet = false;
// Get the input filenames
int i = 0;
foreach (var input in args)
{
i++;
switch (input)
{
case "-s":
simulationInputFilePath = args[i];
simulationSet = true;
break;
case "-t":
targetDeckFilePath = args[i];
targetSet = true;
break;
case "-m":
modelInputFilePath = args[i];
modelSet = true;
break;
}
}
///add usage statement
if (!simulationSet)
{
log.Info("Using Default Simulation File");
}
if (!targetSet)
{
log.Info("Using Default Target File");
}
if (!modelSet)
{
log.Info("Using Default Model File");
}
// Initialize Output File
var outputFileName = string.Format("output-{0:yyyy-MM-dd}-*", DateTime.Now);
var outputPath = @"C:\HorizonLog\";
var txt = ".txt";
string[] fileNames = System.IO.Directory.GetFiles(outputPath, outputFileName, System.IO.SearchOption.TopDirectoryOnly);
double number = 0;
foreach (var fileName in fileNames)
{
char version = fileName[fileName.Length - txt.Length - 1];
if (number < Char.GetNumericValue(version))
{
number = Char.GetNumericValue(version);
}
}
number++;
outputFileName = outputFileName.Remove(outputFileName.Length - 1) + number;
outputPath += outputFileName + txt;
// Find the main input node from the XML input files
XmlNode evaluatorNode = XmlParser.ParseSimulationInput(simulationInputFilePath);
// Load the target deck into the targets list from the XML target deck input file
Stack <Task> systemTasks = new Stack <Task>();
bool targetsLoaded = Task.loadTargetsIntoTaskList(XmlParser.GetTargetNode(targetDeckFilePath), systemTasks);
if (!targetsLoaded)
{
return(1);
}
// Find the main model node from the XML model input file
var modelInputXMLNode = XmlParser.GetModelNode(modelInputFilePath);
// Load the environment. First check if there is an ENVIRONMENT XMLNode in the input file
Universe SystemUniverse = null;
//Create singleton dependency dictionary
Dependency dependencies = Dependency.Instance;
// Initialize List to hold assets and subsystem nodes
List <Asset> assetList = new List <Asset>();
List <Subsystem> subList = new List <Subsystem>();
// Maps used to set up preceeding nodes
Dictionary <ISubsystem, XmlNode> subsystemXMLNodeMap = new Dictionary <ISubsystem, XmlNode>();
Dictionary <string, Subsystem> subsystemMap = new Dictionary <string, Subsystem>();
List <KeyValuePair <string, string> > dependencyMap = new List <KeyValuePair <string, string> >();
List <KeyValuePair <string, string> > dependencyFcnMap = new List <KeyValuePair <string, string> >();
// Dictionary<string, ScriptedSubsystem> scriptedSubNames = new Dictionary<string, ScriptedSubsystem>();
// Create Constraint list
List <Constraint> constraintsList = new List <Constraint>();
//Create Lists to hold all the initial condition and dependency nodes to be parsed later
List <XmlNode> ICNodes = new List <XmlNode>();
List <XmlNode> DepNodes = new List <XmlNode>();
SystemState initialSysState = new SystemState();
// Set up Subsystem Nodes, first loop through the assets in the XML model input file
foreach (XmlNode modelChildNode in modelInputXMLNode.ChildNodes)
{
if (modelChildNode.Name.Equals("ENVIRONMENT"))
{
// Create the Environment based on the XMLNode
SystemUniverse = new Universe(modelChildNode);
}
if (modelChildNode.Name.Equals("ASSET"))
{
Asset asset = new Asset(modelChildNode);
assetList.Add(asset);
// Loop through all the of the ChildNodess for this Asset
foreach (XmlNode childNode in modelChildNode.ChildNodes)
{
// Get the current Subsystem XML Node, and create it using the SubsystemFactory
if (childNode.Name.Equals("SUBSYSTEM"))
{ //is this how we want to do this?
// Check if the type of the Subsystem is scripted, networked, or other
string subName = SubsystemFactory.GetSubsystem(childNode, dependencies, asset, subsystemMap);
foreach (XmlNode ICorDepNode in childNode.ChildNodes)
{
if (ICorDepNode.Name.Equals("IC"))
{
ICNodes.Add(ICorDepNode);
}
if (ICorDepNode.Name.Equals("DEPENDENCY"))
{
string depSubName = "", depFunc = "";
depSubName = Subsystem.parseNameFromXmlNode(ICorDepNode, asset.Name);
dependencyMap.Add(new KeyValuePair <string, string>(subName, depSubName));
if (ICorDepNode.Attributes["fcnName"] != null)
{
depFunc = ICorDepNode.Attributes["fcnName"].Value.ToString();
dependencyFcnMap.Add(new KeyValuePair <string, string>(subName, depFunc));
}
}
}
}
//Create a new Constraint
if (childNode.Name.Equals("CONSTRAINT"))
{
constraintsList.Add(ConstraintFactory.GetConstraint(childNode, subsystemMap, asset));
}
}
if (ICNodes.Count > 0)
{
initialSysState.Add(SystemState.setInitialSystemState(ICNodes, asset));
}
ICNodes.Clear();
}
}
if (SystemUniverse == null)
{
SystemUniverse = new Universe();
}
foreach (KeyValuePair <string, Subsystem> sub in subsystemMap)
{
if (!sub.Value.GetType().Equals(typeof(ScriptedSubsystem)))//let the scripted subsystems add their own dependency collector
{
sub.Value.AddDependencyCollector();
}
subList.Add(sub.Value);
}
log.Info("Subsystems and Constraints Loaded");
//Add all the dependent subsystems to the dependent subsystem list of the subsystems
foreach (KeyValuePair <string, string> depSubPair in dependencyMap)
{
Subsystem subToAddDep, depSub;
subsystemMap.TryGetValue(depSubPair.Key, out subToAddDep);
subsystemMap.TryGetValue(depSubPair.Value, out depSub);
subToAddDep.DependentSubsystems.Add(depSub);
}
//give the dependency functions to all the subsytems that need them
foreach (KeyValuePair <string, string> depFunc in dependencyFcnMap)
{
Subsystem subToAddDep;
subsystemMap.TryGetValue(depFunc.Key, out subToAddDep);
subToAddDep.SubsystemDependencyFunctions.Add(depFunc.Value, dependencies.GetDependencyFunc(depFunc.Value));
}
log.Info("Dependencies Loaded");
SystemClass simSystem = new SystemClass(assetList, subList, constraintsList, SystemUniverse);
if (simSystem.CheckForCircularDependencies())
{
throw new NotFiniteNumberException("System has circular dependencies! Please correct then try again.");
}
Evaluator schedEvaluator = EvaluatorFactory.GetEvaluator(evaluatorNode, dependencies);
Scheduler scheduler = new Scheduler(schedEvaluator);
List <SystemSchedule> schedules = scheduler.GenerateSchedules(simSystem, systemTasks, initialSysState);
// Evaluate the schedules and set their values
foreach (SystemSchedule systemSchedule in schedules)
{
systemSchedule.ScheduleValue = schedEvaluator.Evaluate(systemSchedule);
bool canExtendUntilEnd = true;
// Extend the subsystem states to the end of the simulation
foreach (var subsystem in simSystem.Subsystems)
{
if (systemSchedule.AllStates.Events.Count > 0)
{
if (!subsystem.CanExtend(systemSchedule.AllStates.Events.Peek(), simSystem.Environment, SimParameters.SimEndSeconds))
{
log.Error("Cannot Extend " + subsystem.Name + " to end of simulation");
}
}
}
}
// Sort the sysScheds by their values
schedules.Sort((x, y) => x.ScheduleValue.CompareTo(y.ScheduleValue));
schedules.Reverse();
double maxSched = schedules[0].ScheduleValue;
i = 0;
//Morgan's Way
using (StreamWriter sw = File.CreateText(outputPath))
{
foreach (SystemSchedule sched in schedules)
{
sw.WriteLine("Schedule Number: " + i + "Schedule Value: " + schedules[i].ScheduleValue);
foreach (var eit in sched.AllStates.Events)
{
if (i < 5)//just compare the first 5 schedules for now
{
sw.WriteLine(eit.ToString());
}
}
i++;
}
log.Info("Max Schedule Value: " + maxSched);
}
// Mehiel's way
string stateDataFilePath = @"C:\HorizonLog\" + string.Format("output-{0:yyyy-MM-dd-hh-mm-ss}", DateTime.Now);
SystemSchedule.WriteSchedule(schedules[0], stateDataFilePath);
var csv = new StringBuilder();
csv.Clear();
foreach (var asset in simSystem.Assets)
{
File.WriteAllText(@"..\..\..\" + asset.Name + "_dynamicStateData.csv", asset.AssetDynamicState.ToString());
}
return(0);
// Console.ReadKey();
}