public override bool UpdateTestBenchManifestExecutionSteps(AVM.DDP.MetaTBManifest manifest)
{
manifest.Steps.Add(new AVM.DDP.MetaTBManifest.Step()
{
Invocation = "python.exe -E -m run_mdao",
Description = "ParametricExploration",
// Type = "Parametric Study",
Status = AVM.DDP.MetaTBManifest.StatusEnum.UNEXECUTED
});
return(true);
}
public override bool UpdateTestBenchManifestExecutionSteps(AVM.DDP.MetaTBManifest manifest)
{
manifest.Steps.Add(new AVM.DDP.MetaTBManifest.Step()
{
Invocation = String.Format("\"{0}\" -E -m run_mdao", VersionInfo.PythonVEnvExe),
Description = "ParametricExploration",
// Type = "Parametric Study",
Status = AVM.DDP.MetaTBManifest.StatusEnum.UNEXECUTED
});
return(true);
}
public void SaveTestBenchManifest(string outputDirectory, CyPhy.TestBenchType testBenchType)
{
if (testBenchType == null)
{
throw new ArgumentNullException();
}
if (outputDirectory == null)
{
throw new ArgumentNullException();
}
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(testBenchType, outputDirectory);
manifest.Serialize(outputDirectory);
}
public override bool UpdateTestBenchManifestExecutionSteps(AVM.DDP.MetaTBManifest manifest)
{
this.ExecuteInTransaction(() =>
{
try
{
manifest.AddAllTasks(this.testBenchType, this.Interpreters, "..\\..");
}
catch (Exception ex)
{
throw new AnalysisModelProcessorException("Updating test bench execution steps failed.", ex);
}
});
return(true);
}
/// <summary>
/// Call this function if a GME transaction is open.
/// </summary>
/// <param name="testBenchName"></param>
/// <param name="interpreterOutputDir"></param>
/// <param name="fco"></param>
public void SaveSummaryReportJson(string interpreterOutputDir, MgaFCO fco)
{
// TODO: index result file!
if (fco.Meta.Name == "TestBench")
{
CyPhy.TestBench tb = ISIS.GME.Dsml.CyPhyML.Classes.TestBench.Cast(fco as MgaObject);
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(tb, interpreterOutputDir);
manifest.Serialize(interpreterOutputDir);
}
else if (fco.Meta.Name == "CADTestBench")
{
var tb = ISIS.GME.Dsml.CyPhyML.Classes.CADTestBench.Cast(fco as MgaObject);
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(tb, interpreterOutputDir);
manifest.Serialize(interpreterOutputDir);
}
}
public void SaveTestBenchManifest(string designName, string configurationName, string testBenchName, FCO expandedTestBenchType, string outputDir, DateTime analysisStartTime)
{
if (outputDir == null)
{
throw new ArgumentNullException("outputDirectory");
}
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(expandedTestBenchType, outputDir);
// design name fixture
manifest.DesignName = designName;
// test bench name fixture
manifest.TestBench = testBenchName;
manifest.CfgID = configurationName;
manifest.Serialize(outputDir);
this.UpdateResultsJson(expandedTestBenchType.Impl as MgaFCO, outputDir, analysisStartTime);
}
// META-2987
private void GenerateCADParameterMapping(CyPhy.TestBenchType testBench, string outputDir, List <object> cadParamList)
{
foreach (var parameter in testBench.Children.ParameterCollection)
{
List <CyPhy.CADParameter> vftFound = new List <CyPhy.CADParameter>();
List <CyPhy.ValueFlowTarget> vftVisited = new List <CyPhy.ValueFlowTarget>();
FindValueFlowTargets(parameter,
vftFound,
vftVisited);
foreach (var cadParam in vftFound)
{
CyPhy2CAD_CSharp.TestBenchModel.TBCadParameterMapping cadParameterMapping = new TestBenchModel.TBCadParameterMapping(cadParam, parameter.Name);
if (!String.IsNullOrEmpty(cadParameterMapping.ComponentInstanceGUID))
{
cadParamList.Add(cadParameterMapping);
}
}
}
if (cadParamList.Any())
{
string mappingFileContent = Newtonsoft.Json.JsonConvert.SerializeObject(cadParamList);
File.WriteAllText(Path.Combine(outputDir, "CADParamTestBenchMapping.json"), mappingFileContent, new UTF8Encoding(false));
}
// generate testbench_manifest.json if it does not exist
if (true /*!File.Exists(Path.Combine(outputDir, "testbench_manifest.json"))*/)
{
AVM.DDP.MetaTBManifest tbManifest = new AVM.DDP.MetaTBManifest();
tbManifest.MakeManifest(testBench,
outputDir);
tbManifest.Serialize(outputDir);
}
}
/// <summary>
/// Call this function if a GME transaction is open.
/// </summary>
/// <param name="testBenchName"></param>
/// <param name="interpreterOutputDir"></param>
/// <param name="fco"></param>
public void SaveSummaryReportJson(string interpreterOutputDir, MgaFCO fco)
{
// TODO: index result file!
if (fco.Meta.Name == "TestBench")
{
CyPhy.TestBench tb = ISIS.GME.Dsml.CyPhyML.Classes.TestBench.Cast(fco as MgaObject);
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(tb, interpreterOutputDir);
manifest.Serialize(interpreterOutputDir);
}
else if (fco.Meta.Name == "CADTestBench")
{
var tb = ISIS.GME.Dsml.CyPhyML.Classes.CADTestBench.Cast(fco as MgaObject);
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(tb, interpreterOutputDir);
manifest.Serialize(interpreterOutputDir);
}
}
/// <summary> /// Updates the execution steps in the test bench manifest file based on the Tasks and Execution tasks in the /// workflow. /// </summary> /// <returns>True if all Tasks were successfully added, false otherwise.</returns> public abstract bool UpdateTestBenchManifestExecutionSteps(AVM.DDP.MetaTBManifest manifest);
public void SaveTestBenchManifest(string outputDirectory, CyPhy.TestBenchType testBenchType)
{
if (testBenchType == null)
{
throw new ArgumentNullException();
}
if (outputDirectory == null)
{
throw new ArgumentNullException();
}
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(testBenchType, outputDirectory);
manifest.Serialize(outputDirectory);
}
public bool SaveTestBenchManifest(string designName, string configurationName, CyPhy.TestBenchType expandedTestBenchType, string outputDir, CyPhy.TestBenchType origialTestBenchType, DateTime analysisStartTime)
{
if (expandedTestBenchType == null)
{
throw new ArgumentNullException("expandedTestBenchType");
}
if (outputDir == null)
{
throw new ArgumentNullException("outputDirectory");
}
if (origialTestBenchType == null)
{
expandedTestBenchType = origialTestBenchType;
}
try
{
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(expandedTestBenchType, outputDir);
// design name fixture
manifest.DesignName = designName;
// test bench name fixture
manifest.TestBench = origialTestBenchType.Name;
manifest.CfgID = configurationName;
manifest.Serialize(outputDir);
this.UpdateResultsJson(expandedTestBenchType.Impl as MgaFCO, outputDir);
return true;
}
catch (Exception)
{
// TODO: log exception/store last exception
return false;
}
}
private static int ParseArgs(string[] args, out MfgBom.CostEstimation.CostEstimationRequest Request, out AVM.DDP.MetaTBManifest Manifest, out String pathResultsFolder)
{
Request = null;
Manifest = null;
pathResultsFolder = "";
var pathManifest = args[0];
if (false == File.Exists(pathManifest))
{
Console.Error.WriteLine("No file found at location: {0}",
pathManifest);
return(-2);
}
pathResultsFolder = Path.GetDirectoryName(pathManifest);
Manifest = AVM.DDP.MetaTBManifest.OpenForUpdate(pathResultsFolder);
if (null == Manifest)
{
Console.Error.WriteLine("Manifest is empty or didn't load correctly: {0}",
pathManifest);
return(-3);
}
var artifactRequest = Manifest.Artifacts.FirstOrDefault(a => a.Tag == "CyPhy2MfgBom::CostEstimationRequest");
if (null == artifactRequest)
{
Console.Error.WriteLine("Didn't find any artifacts in the manifest with the tag \"CyPhy2MfgBom::CostEstimationRequest\": {0}",
pathManifest);
return(-4);
}
var pathRequest = Path.Combine(pathResultsFolder,
artifactRequest.Location);
if (false == File.Exists(pathRequest))
{
Console.Error.WriteLine("Couldn't find the file tagged with \"CyPhy2MfgBom::CostEstimationRequest\" at given path: {0}",
pathRequest);
return(-5);
}
String jsonRequest;
try
{
jsonRequest = File.ReadAllText(pathRequest);
Request = MfgBom.CostEstimation.CostEstimationRequest.Deserialize(jsonRequest);
}
catch (Exception ex)
{
Console.Error.WriteLine("Exception loading the cost estimation request at \"{0}\": {1}",
pathRequest,
ex);
return(-6);
}
return(0);
}
// META-2987
private void GenerateCADParameterMapping(CyPhy.TestBenchType testBench,
string outputDir)
{
List<CyPhy2CAD_CSharp.TestBenchModel.TBCadParameterMapping> cadParamList = new List<TestBenchModel.TBCadParameterMapping>();
if (testBench.Children.ParameterCollection.Any())
{
foreach (var parameter in testBench.Children.ParameterCollection)
{
List<CyPhy.CADParameter> vftFound = new List<CyPhy.CADParameter>();
List<CyPhy.ValueFlowTarget> vftVisited = new List<CyPhy.ValueFlowTarget>();
FindValueFlowTargets(parameter,
vftFound,
vftVisited);
foreach (var cadParam in vftFound)
{
CyPhy2CAD_CSharp.TestBenchModel.TBCadParameterMapping cadParameterMapping = new TestBenchModel.TBCadParameterMapping(cadParam, parameter.Name);
if (!String.IsNullOrEmpty(cadParameterMapping.ComponentInstanceGUID))
cadParamList.Add(cadParameterMapping);
}
}
}
if (cadParamList.Any())
{
string mappingFileContent = Newtonsoft.Json.JsonConvert.SerializeObject(cadParamList);
using (StreamWriter writer = new StreamWriter(Path.Combine(outputDir, "CADParamTestBenchMapping.json")))
{
writer.WriteLine(mappingFileContent);
}
}
// generate testbench_manifest.json if it does not exist
if (true/*!File.Exists(Path.Combine(outputDir, "testbench_manifest.json"))*/)
{
AVM.DDP.MetaTBManifest tbManifest = new AVM.DDP.MetaTBManifest();
tbManifest.MakeManifest(testBench,
outputDir);
tbManifest.Serialize(outputDir);
}
}
public bool Generate(string originalDesignName)
{
var testBench = CyPhyClasses.TestBench.Cast(this.mainParameters.CurrentFCO);
// generate new manifest file
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(testBench, this.mainParameters.OutputDirectory);
if (string.IsNullOrWhiteSpace(originalDesignName) == false)
{
manifest.DesignName = originalDesignName;
}
else
{
this.Logger.WriteWarning("Could not find an original design. Manifest file will use the name of the test-bench, i.e. '{0}'.", testBench.Name);
}
manifest.Serialize(this.mainParameters.OutputDirectory);
// create scripts directory
string scriptDir = Path.Combine(this.mainParameters.OutputDirectory, "scripts");
Directory.CreateDirectory(scriptDir);
// create modelica libraries directory
string modelicaDir = Path.Combine(this.mainParameters.OutputDirectory, "Libraries");
Directory.CreateDirectory(modelicaDir);
// get CyPhy directory
string cyphyDir = Path.Combine(this.mainParameters.OutputDirectory, Modelica.CodeGenerator.MainPackage);
// copy libraries into the output directory
var settings = this.mainParameters.config as CyPhy2Modelica_v2Settings;
foreach (var library in settings.IncludeDirectoryPath)
{
var sourcePath = library;
if (Path.GetFileName(library) == "package.mo")
{
sourcePath = Path.GetDirectoryName(library);
}
if (Path.IsPathRooted(sourcePath) == false)
{
// Relative paths are defined relative to the project!
sourcePath = Path.Combine(this.mainParameters.ProjectDirectory, sourcePath);
}
// TODO: Move this to the Checker
if ((File.Exists(sourcePath) || Directory.Exists(sourcePath)) == false)
{
this.Logger.WriteError("External Modelica Library does not exist at {0}.", sourcePath);
continue;
}
var destinationPath = Path.Combine(modelicaDir, Path.GetFileName(sourcePath));
if (sourcePath.EndsWith(".mo") == false)
{
Directory.CreateDirectory(destinationPath);
// Create all of the directories
foreach (string dirPath in Directory.GetDirectories(sourcePath, "*", SearchOption.AllDirectories))
{
if (dirPath.Split(Path.DirectorySeparatorChar)
.Where(dir => dir == ".svn" || dir == ".git").Count() > 0)
{
continue;
}
Directory.CreateDirectory(dirPath.Replace(sourcePath, destinationPath));
}
// Copy all the files
foreach (string newPath in Directory.GetFiles(sourcePath, "*.*", SearchOption.AllDirectories))
{
if (newPath.Split(Path.DirectorySeparatorChar)
.Where(dir => dir == ".svn" || dir == ".git").Count() > 0)
{
continue;
}
File.Copy(newPath, newPath.Replace(sourcePath, destinationPath), true);
}
}
else
{
File.Copy(sourcePath, destinationPath, true);
}
this.Logger.WriteDebug("Copied library from {0} to {1}", sourcePath, destinationPath);
}
Templates.open_package_in_dymola dymola_open = new Templates.open_package_in_dymola();
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "open_in_dymola.cmd"), dymola_open.TransformText());
Templates.open_package_in_om om_open = new Templates.open_package_in_om();
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "open_in_om.cmd"), om_open.TransformText());
// generate scripts
Templates.dymola_simulate dymola_sim = new Templates.dymola_simulate();
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "simulate_dymola.cmd"), dymola_sim.TransformText());
Templates.om_simulate om_sim = new Templates.om_simulate();
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "simulate_om.cmd"), om_sim.TransformText());
Templates.jmodelica_simulate jmodelica_sim = new Templates.jmodelica_simulate();
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "simulate_jmodelica.cmd"), jmodelica_sim.TransformText());
var solver = new Modelica.SolverSettings(testBench.Children.SolverSettingsCollection.FirstOrDefault());
if (solver.ToolSelection.Contains("OpenModelica"))
{
this.RunCommand = "simulate_om.cmd " + solver.ToolSelection;
}
else if (solver.ToolSelection.Contains("Dymola"))
{
this.RunCommand = "simulate_dymola.cmd " + solver.ToolSelection;
}
else if (solver.ToolSelection.Contains("JModelica"))
{
this.RunCommand = "simulate_jmodelica.cmd " + solver.ToolSelection;
Templates.jmodelica_compile_py jmodelica_compile = new Templates.jmodelica_compile_py();
File.WriteAllText(Path.Combine(scriptDir, "jmodelica_compile.py"), jmodelica_compile.TransformText());
Templates.jmodelica_simulate_py jmodelica_simulate = new Templates.jmodelica_simulate_py();
File.WriteAllText(Path.Combine(scriptDir, "jmodelica_simulate.py"), jmodelica_simulate.TransformText());
}
else
{
throw new NotSupportedException(solver.ToolSelection);
}
Templates.simulate_py simulate_py = new Templates.simulate_py();
File.WriteAllText(Path.Combine(scriptDir, "simulate.py"), simulate_py.TransformText());
//Templates.compile_and_run_jmodelica_py run_jmodelica = new Templates.compile_and_run_jmodelica_py();
//File.WriteAllText(Path.Combine(scriptDir, "compile_and_run_jmodelica.py"), run_jmodelica.TransformText());
this.CurrentModelConfig = this.GenerateModelConfig(Path.Combine(this.mainParameters.OutputDirectory, Modelica.CodeGenerator.MainPackage), testBench, settings.IncludeDirectoryPath);
this.CopyOverPostProcessingScripts(Path.Combine(this.mainParameters.OutputDirectory, Modelica.CodeGenerator.MainPackage), testBench);
this.LimitChecks(Path.Combine(this.mainParameters.OutputDirectory, Modelica.CodeGenerator.MainPackage), this.CurrentModelConfig.result_file);
return true;
}
public bool Generate(string originalDesignName)
{
var testBench = CyPhyClasses.TestBench.Cast(this.mainParameters.CurrentFCO);
// generate new manifest file
AVM.DDP.MetaTBManifest manifest = new AVM.DDP.MetaTBManifest();
manifest.MakeManifest(testBench, this.mainParameters.OutputDirectory);
if (string.IsNullOrWhiteSpace(originalDesignName) == false)
{
manifest.DesignName = originalDesignName;
}
else
{
this.Logger.WriteWarning("Could not find an original design. Manifest file will use the name of the test-bench, i.e. '{0}'.", testBench.Name);
}
manifest.Serialize(this.mainParameters.OutputDirectory);
// create scripts directory
string scriptDir = Path.Combine(this.mainParameters.OutputDirectory, "scripts");
Directory.CreateDirectory(scriptDir);
// create modelica libraries directory
string modelicaDir = Path.Combine(this.mainParameters.OutputDirectory, "Libraries");
Directory.CreateDirectory(modelicaDir);
// get CyPhy directory
string cyphyDir = Path.Combine(this.mainParameters.OutputDirectory, Modelica.CodeGenerator.MainPackage);
// copy libraries into the output directory
var settings = this.mainParameters.config as CyPhy2Modelica_v2Settings;
foreach (var library in settings.IncludeDirectoryPath)
{
var sourcePath = library;
if (Path.GetFileName(library) == "package.mo")
{
sourcePath = Path.GetDirectoryName(library);
}
if (Path.IsPathRooted(sourcePath) == false)
{
// Relative paths are defined relative to the project!
sourcePath = Path.Combine(this.mainParameters.ProjectDirectory, sourcePath);
}
// TODO: Move this to the Checker
if ((File.Exists(sourcePath) || Directory.Exists(sourcePath)) == false)
{
this.Logger.WriteError("External Modelica Library does not exist at {0}.", sourcePath);
continue;
}
var destinationPath = Path.Combine(modelicaDir, Path.GetFileName(sourcePath));
if (sourcePath.EndsWith(".mo") == false)
{
Directory.CreateDirectory(destinationPath);
// Create all of the directories
foreach (string dirPath in Directory.GetDirectories(sourcePath, "*", SearchOption.AllDirectories))
{
if (dirPath.Split(Path.DirectorySeparatorChar)
.Where(dir => dir == ".svn" || dir == ".git").Count() > 0)
{
continue;
}
Directory.CreateDirectory(dirPath.Replace(sourcePath, destinationPath));
}
// Copy all the files
foreach (string newPath in Directory.GetFiles(sourcePath, "*.*", SearchOption.AllDirectories))
{
if (newPath.Split(Path.DirectorySeparatorChar)
.Where(dir => dir == ".svn" || dir == ".git").Count() > 0)
{
continue;
}
File.Copy(newPath, newPath.Replace(sourcePath, destinationPath), true);
}
}
else
{
File.Copy(sourcePath, destinationPath, true);
}
this.Logger.WriteDebug("Copied library from {0} to {1}", sourcePath, destinationPath);
}
Templates.open_package_in_dymola dymola_open = new Templates.open_package_in_dymola();
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "open_in_dymola.cmd"), dymola_open.TransformText());
Templates.open_package_in_om om_open = new Templates.open_package_in_om();
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "open_in_om.cmd"), om_open.TransformText());
// generate scripts
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "simulate_dymola.cmd"),
CyPhy2Modelica_v2.Properties.Resources._simulate_cmd.Replace("TOOL_TO_BE_REPLACED", "Dymola"));
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "simulate_om.cmd"),
CyPhy2Modelica_v2.Properties.Resources._simulate_cmd.Replace("TOOL_TO_BE_REPLACED", "OpenModelica"));
File.WriteAllText(Path.Combine(this.mainParameters.OutputDirectory, "simulate_jmodelica.cmd"),
CyPhy2Modelica_v2.Properties.Resources._simulate_cmd.Replace("TOOL_TO_BE_REPLACED", "JModelica"));
var solver = new Modelica.SolverSettings(testBench.Children.SolverSettingsCollection.FirstOrDefault());
if (solver.ToolSelection.Contains("OpenModelica"))
{
this.RunCommand = "simulate_om.cmd";
}
else if (solver.ToolSelection.Contains("Dymola"))
{
this.RunCommand = "simulate_dymola.cmd";
}
else if (solver.ToolSelection.Contains("JModelica"))
{
this.RunCommand = "simulate_jmodelica.cmd";
Templates.jmodelica_compile_py jmodelica_compile = new Templates.jmodelica_compile_py();
File.WriteAllText(Path.Combine(scriptDir, "jmodelica_compile.py"), jmodelica_compile.TransformText());
Templates.jmodelica_simulate_py jmodelica_simulate = new Templates.jmodelica_simulate_py();
File.WriteAllText(Path.Combine(scriptDir, "jmodelica_simulate.py"), jmodelica_simulate.TransformText());
}
else
{
throw new NotSupportedException(solver.ToolSelection);
}
Templates.simulate_py simulate_py = new Templates.simulate_py();
File.WriteAllText(Path.Combine(scriptDir, "simulate.py"), simulate_py.TransformText());
//Templates.compile_and_run_jmodelica_py run_jmodelica = new Templates.compile_and_run_jmodelica_py();
//File.WriteAllText(Path.Combine(scriptDir, "compile_and_run_jmodelica.py"), run_jmodelica.TransformText());
this.CurrentModelConfig = this.GenerateModelConfig(Path.Combine(this.mainParameters.OutputDirectory, Modelica.CodeGenerator.MainPackage), testBench, settings.IncludeDirectoryPath);
this.CopyOverPostProcessingScripts(Path.Combine(this.mainParameters.OutputDirectory, Modelica.CodeGenerator.MainPackage), testBench);
this.LimitChecks(Path.Combine(this.mainParameters.OutputDirectory, Modelica.CodeGenerator.MainPackage), this.CurrentModelConfig.result_file);
return(true);
}
public override bool UpdateTestBenchManifestExecutionSteps(AVM.DDP.MetaTBManifest manifest)
{
// FIXME: return fake true for now.
return(true);
}
