public CFDConfig(CyPhy.CFDSolverSetting setting,
CyPhy.CFDTestBench testBench)
{
MeshFineness = (int)testBench.Attributes.MeshFineness + 1;
SimulationTime = testBench.Attributes.SimulationTime;
Core = testBench.Attributes.Core.ToString();
}
public static void SetCADModelTypesFromFilenames(CyPhyML.Component c)
{
foreach (CyPhyML.CADModel cadModel in c.Children.CADModelCollection)
{
List<ISIS.GME.Common.Interfaces.FCO> resources = new List<ISIS.GME.Common.Interfaces.FCO>();
foreach (var usesResource in cadModel.DstConnections.UsesResourceCollection)
{
resources.Add(usesResource.DstEnd);
}
foreach (var usesResource in cadModel.SrcConnections.UsesResourceCollection)
{
resources.Add(usesResource.SrcEnd);
}
foreach (var resource in resources.Where(f => f.Impl.MetaBase.Name == "Resource")
.Select(f => CyPhyMLClasses.Resource.Cast(f.Impl)))
{
if (resource.Attributes.Path.EndsWith(".prt") || resource.Attributes.Path.EndsWith(".PRT"))
{
cadModel.Attributes.FileType = CyPhyMLClasses.CADModel.AttributesClass.FileType_enum.Part;
}
if (resource.Attributes.Path.EndsWith(".asm") || resource.Attributes.Path.EndsWith(".ASM"))
{
cadModel.Attributes.FileType = CyPhyMLClasses.CADModel.AttributesClass.FileType_enum.Assembly;
}
}
}
}
private void VisitConnector(CyPhy.Connector connector, MgaFCO parent)
{
if (!visitedPorts.Contains(connector.ID + "_" + parent.ID))
{
visitedPorts.Add(connector.ID + "_" + parent.ID);
bool parentIsComponent = (connector.ParentContainer is CyPhy.Component);
bool isStart = (connector.ID == startNodeID);
if (!isStart && parentIsComponent)
{
FoundConnectedNodes.Add(connector);
}
foreach (CyPhy.ConnectorComposition conn in connector.SrcConnections.ConnectorCompositionCollection)
{
if (topAssembly != null && !IsParent(conn, topAssembly)) continue;
if (parent.ObjType != GME.MGA.Meta.objtype_enum.OBJTYPE_REFERENCE ||
GetRefportOrParent((MgaConnection) conn.Impl, "src").ID == parent.ID)
VisitConnector(conn.SrcEnds.Connector, parent);
}
foreach (CyPhy.ConnectorComposition conn in connector.DstConnections.ConnectorCompositionCollection)
{
if (topAssembly != null && !IsParent(conn, topAssembly)) continue;
if (parent.ObjType != GME.MGA.Meta.objtype_enum.OBJTYPE_REFERENCE ||
GetRefportOrParent((MgaConnection)conn.Impl, "dst").ID == parent.ID)
VisitConnector(conn.DstEnds.Connector, parent);
}
}
}
private void CollectLeafComponents(List<CyPhy.Component> result, CyPhy.ComponentAssembly assembly)
{
foreach (var compref in assembly.Children.ComponentRefCollection)
{
if (compref.AllReferred != null)
{
if (compref.AllReferred is CyPhy.ComponentAssemblyRef)
{
CollectLeafComponents(result, compref.AllReferred as CyPhy.ComponentAssembly);
}
else if (compref.AllReferred is CyPhy.Component)
{
// Interested in components with CAD Model only
if ((compref.AllReferred as CyPhy.Component).Children.CADModelCollection.Any())
result.Add(compref as CyPhy.Component);
}
}
}
foreach (var compass in assembly.Children.ComponentAssemblyCollection)
{
CollectLeafComponents(result, compass);
}
foreach (var comp in assembly.Children.ComponentCollection)
{
// Interested in components with CAD Model only
if ((comp as CyPhy.Component).Children.CADModelCollection.Any())
result.Add(comp);
}
}
/// <summary>
/// Injects Meta-Link related data into a pre-existing structure
/// </summary>
/// <param name="assembly"></param>
public void InjectMetaLinkData(CyPhy.ComponentAssembly assembly, MetaLinkData data)
{
// There's only one cadassembly in case of Meta-Link!!
foreach (DataRep.CADAssembly a in assemblies.Values)
{
a.MetaLinkData = data;
}
}
public TBCadParameterMapping(CyPhy.CADParameter cadParam,
string tbParamName)
{
ComponentCADParameterName = cadParam.Attributes.ParameterName;
if (cadParam.ParentContainer.ParentContainer.Kind == "Component")
ComponentInstanceGUID = CyPhyClasses.Component.Cast(cadParam.ParentContainer.ParentContainer.Impl).Attributes.InstanceGUID;
TestBenchParameterName = tbParamName;
}
public TestBenchTypeProcessor(CyPhy.TestBenchType testBenchType)
{
this.testBenchType = testBenchType;
this.OriginalSystemUnderTest = testBenchType.Children.TopLevelSystemUnderTestCollection.FirstOrDefault();
// HACK: used by PET, SoT and CyPhy2Modelica_v2 [old code]
this.GetInvokedObject().RegistryValue["TestBenchUniqueName"] = this.testBenchType.Name;
}
public CommonTraversal(CyPhy.ConnectorComposition connection, CyPhy.ComponentAssembly topassembly)
{
Initialize();
startNodeID = "";
this.topAssembly = topassembly;
VisitConnectorComposition(connection);
}
public void CreateFlatData(CyPhy.ComponentAssembly cyphyasm)
{
List<CyPhy.Component> regular = new List<CyPhy.Component>();
List<CyPhy.Component> size2fitcomponents = new List<CyPhy.Component>();
// [1] Grabs all components
FindComponents(cyphyasm, regular, size2fitcomponents);
ProcessComponents(regular, size2fitcomponents, cyphyasm);
}
public CalmWaterSolverSettings(CyPhy.CalmWaterSolverSettings settings,
CyPhy.CFDTestBench testBench)
: base(settings,
testBench)
{
Tier = 3;
FluidMaterial = (MaterialType)(int)settings.Attributes.FluidMaterial;
FluidTemperature = settings.Attributes.FluidTemperature;
VehicleVelocity = settings.Attributes.VehicleVelocity;
}
private bool GetParamUnitName(CyPhy.Parameter param, ref string unit)
{
if (param.AllReferred as CyPhy.unit != null)
{
unit = (param.AllReferred as CyPhy.unit).Attributes.Symbol;
return true;
} else {
return false;
}
}
public CADComponent(CyPhy.Component cyphycomp, string ProjectDirectory, bool size2fit = false, string format = "Creo")
{
Type = CADDataType.Component;
StructuralInterfaceNodes = new Dictionary<string, StructuralInterfaceConstraint>();
DisplayID = cyphycomp.Attributes.InstanceGUID;
Id = cyphycomp.ID;
GraphvizID = UtilityHelpers.CleanString2(cyphycomp.ID, 50, "-");
AVMID = cyphycomp.Attributes.AVMID;
RevID = "";
VersionID = cyphycomp.Attributes.Version;
CADFormat = format;
Name = cyphycomp.Name;
CadParameters = new List<CADParameter>();
ModelType = "Part";
Size2Fit = size2fit;
MaterialName = "";
CyPhyModelPath = cyphycomp.GetDirectoryPath(ProjectDirectory: ProjectDirectory);
Classification = cyphycomp.Attributes.Classifications;
HyperLink = cyphycomp.ToHyperLink();
CadElementsList = new List<CAD.ElementType>();
pointCoordinatesList = new List<TestBenchModel.TBComputation>();
CreateStructuralInterfaceEquivalent(cyphycomp);
AddManufacturingParameters(cyphycomp);
var specialinstr = cyphycomp.Children.ParameterCollection.Where(p => p.Name.ToUpper() == SpecialInstrParamStr);
if (specialinstr.Any())
{
SpecialInstructions = specialinstr.First().Attributes.Value.Replace("\"", "");
}
// META-3555 hack
if (cyphycomp.Children.CADModelCollection.Any())
{
foreach (var datum in cyphycomp.Children.CADModelCollection.First().Children.CADDatumCollection)
{
if (datum.Name == "FRONT" || datum.Name == "TOP" || datum.Name == "RIGHT")
{
SpecialDatums.Add(new Datum(datum, "", false));
}
}
}
foreach (var prop in cyphycomp.Children.PropertyCollection)
{
if (prop.Name.StartsWith("METADATA."))
{
MetaData.Add(prop.Name.Substring(9), prop.Attributes.Value);
}
}
TraverseComposites(cyphycomp);
CreatePointCoordinatesList(cyphycomp);
}
public override void Expand(CyPhy.ComponentAssembly configuration)
{
this.Configuration = configuration;
if (this.OriginalSystemUnderTest.Referred.DesignEntity.ID == configuration.ID)
{
this.expandedTestBenchType = this.testBenchType;
}
else
{
// create temp folder for test bench
CyPhy.Testing testing = CyPhyClasses.Testing.Cast(this.testBenchType.ParentContainer.Impl);
var tempFolderName = AnalysisModelProcessor.GetTemporaryFolderName(this.testBenchType.Impl);
CyPhy.Testing tempFolder = testing.Children.TestingCollection.FirstOrDefault(x => x.Name == tempFolderName);
if (tempFolder == null)
{
tempFolder = CyPhyClasses.Testing.Create(testing);
tempFolder.Name = tempFolderName;
this.AddToTraceabilityAndTemporary(tempFolder.Impl, testing.Impl, recursive: false);
}
// copy test bench
var tempCopy = (tempFolder.Impl as MgaFolder).CopyFCODisp(this.testBenchType.Impl as MgaFCO);
// fix name
tempCopy.Name = AnalysisModelProcessor.GetTemporaryObjectName(this.testBenchType.Impl, configuration.Impl);
this.AddToTraceabilityAndTemporary(tempCopy, this.testBenchType.Impl);
// set expanded property to the expanded element
this.expandedTestBenchType = CyPhyClasses.TestBenchType.Cast(tempCopy);
var tlsut = this.expandedTestBenchType.Children.TopLevelSystemUnderTestCollection.FirstOrDefault();
// switch references
try
{
// redirect SUT
var switcher = new ReferenceSwitcher.ReferenceSwitcherInterpreter();
switcher.SwitchReference(configuration.Impl as MgaFCO, tlsut.Impl as IMgaReference);
}
catch (Exception ex)
{
// handle failures for this (use case we can lose ports/connections/
// what if something is an instance/subtype/readonly etc...
throw new AnalysisModelExpandFailedException("ReferenceSwitcher failed.", ex);
}
// redirect TIPs
this.SwitchAllTipReferences();
}
}
private bool IsParent(CyPhy.ConnectorComposition conn, CyPhy.ComponentAssembly topassembly)
{
GmeCommon.Interfaces.Container container = conn.ParentContainer;
while (container != null)
{
if (container.Guid == topAssembly.Guid)
return true;
container = container.ParentContainer;
}
return false;
}
/// <summary>
/// Given a component assembly, ensures that the component assembly has a backend folder
/// for storing resources. Creates a folder if necessary.
/// </summary>
/// <param name="ProjectDirectory">Directory in which the /designs/ folder resides. Defaults to project directory of <paramref name="componentAssembly"/></param>
/// <returns>The path of the ComponentAssembly folder, relative to the project root</returns>
public static String EnsureComponentAssemblyFolder(CyPhy.ComponentAssembly componentAssembly, string ProjectDirectory = null)
{
var mp_MgaProject = componentAssembly.Impl.Project;
String p_ProjectRoot = ProjectDirectory ?? mp_MgaProject.GetRootDirectoryPath();
if (string.IsNullOrEmpty(componentAssembly.Attributes.Path))
{
componentAssembly.Attributes.Path = GetRandomComponentAssemblyDir();
}
Directory.CreateDirectory(Path.Combine(p_ProjectRoot, componentAssembly.Attributes.Path));
return componentAssembly.Attributes.Path;
}
public HydrostaticsSolverSettings(CyPhy.HydrostaticsSolverSettings settings,
CyPhy.CFDTestBench testBench)
: base(settings,
testBench)
{
FluidMaterial = (MaterialType)(int)settings.Attributes.FluidMaterial;
FluidTemperature = settings.Attributes.FluidTemperature;
RollAngleStart = settings.Attributes.RollAngleStart;
RollAngleEnd = settings.Attributes.RollAngleEnd;
RollAngleStep = settings.Attributes.RollAngleStepSize;
PitchAngleStart = settings.Attributes.PitchAngleStart;
PitchAngleEnd = settings.Attributes.PitchAngleEnd;
PitchAngleStep = settings.Attributes.PitchAngleStepSize;
}
public ParametricExplorationProcessor(CyPhy.ParametricExploration parametricExploration)
{
this.parametricExploration = parametricExploration;
this.OriginalSystemUnderTest = parametricExploration
.Children
.TestBenchRefCollection
.FirstOrDefault()
.Referred
.TestBenchType
.Children
.TopLevelSystemUnderTestCollection
.FirstOrDefault();
}
public TestBenchSuiteProcessor(CyPhy.TestBenchSuite testBenchSuite)
{
this.testBenchSuite = testBenchSuite;
this.OriginalSystemUnderTest = testBenchSuite
.Children
.TestBenchRefCollection
.FirstOrDefault()
.Referred
.TestBenchType
.Children
.TopLevelSystemUnderTestCollection
.FirstOrDefault();
}
List<CyPhy.Component> GetAllComponents(CyPhy.Components componentsFolder)
{
List<CyPhy.Component> componentList = new List<CyPhy.Component>();
foreach (CyPhy.Components childComponentsFolder in componentsFolder.Children.ComponentsCollection)
{
componentList.AddRange(GetAllComponents(childComponentsFolder));
}
foreach (CyPhy.Component childComponent in componentsFolder.Children.ComponentCollection)
{
componentList.Add(childComponent);
}
return componentList;
}
public static HashSet<CyPhyML.Component> getCyPhyMLComponentSet(CyPhyML.ComponentAssembly cyPhyMLComponentAssembly) {
HashSet<CyPhyML.Component> cyPhyMLComponentSet = new HashSet<CyPhyML.Component>();
foreach (CyPhyML.ComponentAssembly childComponentAssemblyFolder in cyPhyMLComponentAssembly.Children.ComponentAssemblyCollection) {
cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(childComponentAssemblyFolder));
}
foreach (CyPhyML.Component childComponent in cyPhyMLComponentAssembly.Children.ComponentCollection) {
cyPhyMLComponentSet.Add(childComponent);
}
return cyPhyMLComponentSet;
}
public override void Expand(CyPhy.ComponentAssembly configuration)
{
this.Configuration = configuration;
if (this.OriginalSystemUnderTest.Referred.DesignEntity.ID == configuration.ID)
{
this.expandedTestBenchSuite = this.testBenchSuite;
}
else
{
// create temp folder for test bench suite
CyPhy.TestBenchSuiteFolder testing = CyPhyClasses.TestBenchSuiteFolder.Cast(this.testBenchSuite.ParentContainer.Impl);
var tempFolderName = AnalysisModelProcessor.GetTemporaryFolderName(this.testBenchSuite.Impl);
CyPhy.TestBenchSuiteFolder tempFolder = testing.Children.TestBenchSuiteFolderCollection.FirstOrDefault(x => x.Name == tempFolderName);
if (tempFolder == null)
{
tempFolder = CyPhyClasses.TestBenchSuiteFolder.Create(testing);
tempFolder.Name = tempFolderName;
this.AddToTraceabilityAndTemporary(tempFolder.Impl, testing.Impl, recursive: false);
}
// copy test bench suite
var tempCopy = (tempFolder.Impl as MgaFolder).CopyFCODisp(this.testBenchSuite.Impl as MgaFCO);
// fix name
tempCopy.Name = AnalysisModelProcessor.GetTemporaryObjectName(this.testBenchSuite.Impl, configuration.Impl);
this.AddToTraceabilityAndTemporary(tempCopy, this.testBenchSuite.Impl);
// set expanded property to the expanded element
this.expandedTestBenchSuite = CyPhyClasses.TestBenchSuite.Cast(tempCopy);
}
// expand all test benches
foreach (var testBenchRef in this.expandedTestBenchSuite.Children.TestBenchRefCollection)
{
var testBenchTypeExpander = new TestBenchTypeProcessor(testBenchRef.Referred.TestBenchType);
testBenchTypeExpander.Expand(configuration);
// switch references
var switcher = new ReferenceSwitcher.ReferenceSwitcherInterpreter();
// TODO: handle failures for this
switcher.SwitchReference(testBenchTypeExpander.expandedTestBenchType.Impl as MgaFCO, testBenchRef.Impl as IMgaReference);
this.InnerExpanders.Push(testBenchTypeExpander);
}
}
public static HashSet<CyPhyML.Component> getCyPhyMLComponentSet(CyPhyML.RootFolder cyPhyMLRootFolder) {
HashSet<CyPhyML.Component> cyPhyMLComponentSet = new HashSet<CyPhyML.Component>();
foreach (CyPhyML.Components childComponentsFolder in cyPhyMLRootFolder.Children.ComponentsCollection) {
cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(childComponentsFolder));
}
foreach (CyPhyML.ComponentAssemblies childComponentAssembliesFolder in cyPhyMLRootFolder.Children.ComponentAssembliesCollection) {
cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(childComponentAssembliesFolder));
}
return cyPhyMLComponentSet;
}
public CommonTraversal(GmeCommon.Interfaces.FCO start, CyPhy.ComponentAssembly topassembly)
{
Initialize();
startNodeID = start.ID;
this.topAssembly = topassembly;
if (start is CyPhy.Connector)
{
VisitConnector(start as CyPhy.Connector, (MgaFCO)start.ParentContainer.Impl);
}
else if (start is CyPhy.CADDatum)
{
VisitCADDatum(start as CyPhy.CADDatum);
}
}
public static String ExportToFile(CyPhy.Component c, String s_outFolder)
{
try
{
avm.Component avmComponent = CyPhy2ComponentModel.Convert.CyPhyML2AVMComponent(c);
String s_outFilePath = String.Format("{0}\\{1}.component.acm", s_outFolder, System.IO.Path.GetRandomFileName());
SerializeAvmComponent(avmComponent, s_outFilePath);
return s_outFilePath;
}
catch (Exception ex)
{
var console = GMEConsole.CreateFromProject(c.Impl.Project);
console.Error.WriteLine("Exception Parsing {0}: {1}", Safeify(c.Name), ex.Message);
return null;
}
}
public static HashSet<CyPhyML.Component> getCyPhyMLComponentSet(CyPhyML.TestBench cyPhyMLTestBench) {
HashSet<CyPhyML.Component> cyPhyMLComponentSet = new HashSet<CyPhyML.Component>();
foreach( CyPhyML.TopLevelSystemUnderTest cyPhyMLTopLevelSystemUnderTest in cyPhyMLTestBench.Children.TopLevelSystemUnderTestCollection ) {
CyPhyML.DesignEntity cyPhyMLDesignEntity = cyPhyMLTopLevelSystemUnderTest.Referred as CyPhyML.DesignEntity;
if (cyPhyMLDesignEntity is CyPhyML.ComponentAssembly) {
cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(cyPhyMLDesignEntity as CyPhyML.ComponentAssembly));
}
}
foreach (CyPhyML.ComponentAssembly cyPhyMLComponentAssembly in cyPhyMLTestBench.Children.ComponentAssemblyCollection) {
if ((cyPhyMLComponentAssembly.Impl as MgaFCO).MetaRole.Name != "TopLevelSystemUnderTest") continue;
cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(cyPhyMLComponentAssembly));
}
return cyPhyMLComponentSet;
}
public Datum(CyPhy.CADDatum datum,
string compid, bool guide)
{
DatumName = datum.Attributes.DatumName;
if (datum.Kind == "CoordinateSystem")
Type = DatumType.CSYS;
else if (datum.Kind == "Point")
Type = DatumType.Point;
else if (datum.Kind == "Surface")
Type = DatumType.Surface;
else if (datum.Kind == "Axis")
Type = DatumType.Axis;
ComponentID = compid;
DatumID = datum.ID;
Guide = guide;
if (!String.IsNullOrEmpty(datum.Attributes.GeometricMarker))
Marker = new GeometryMarkerRep(datum.Attributes.GeometricMarker);
}
private CyPhy.Parameter GetForceLoadParam(CyPhy.ForceLoadParam forceload, string name, out double param)
{
try
{
CyPhy.Parameter prm = forceload.Children.ParameterCollection.Where(p => ((MgaFCO)p.Impl).MetaRole.Name == name).First();
param = String.IsNullOrEmpty(prm.Attributes.Value)?0:double.Parse(prm.Attributes.Value);
return prm;
}
catch (InvalidOperationException)
{
Logger.Instance.AddLogMessage("Parameter" + name + " was not found in ForceLoad.", Severity.Error);
}
catch (FormatException)
{
Logger.Instance.AddLogMessage("Parameter" + name + " is not a valid floating point value.", Severity.Error);
}
param = 0;
return null;
}
public CADParameter(CyPhy.CADParameter parameter)
{
Name = (parameter.Attributes.ParameterName == "") ? parameter.Name : parameter.Attributes.ParameterName;
Type = parameter.Attributes.CADParameterType.ToString();
Value = (parameter.Attributes.Value == "") ? (parameter.Attributes.DefaultValue == "") ? "0" : parameter.Attributes.DefaultValue : parameter.Attributes.Value;
Unit = "";
if (parameter.Attributes.Unit == "")
{
if (parameter.Referred != null && parameter.Referred.unit != null)
{
Unit = parameter.Referred.unit.Attributes.Symbol;
}
}
else
{
Unit = parameter.Attributes.Unit;
}
}
private void VerifyBallisticThreat(CyPhy.BallisticThreat threat)
{
if (threat is CyPhy.ProjectileBallisticThreat)
{
CyPhy.ProjectileBallisticThreat t = threat as CyPhy.ProjectileBallisticThreat;
if (t.Attributes.Diameter <= 0)
{
Logger.Instance.AddLogMessage("ProjectileBallisticThreat [" + threat.Name + "] diameter is <= 0", Severity.Warning);
}
if (t.Attributes.Length <= 0)
{
Logger.Instance.AddLogMessage("ProjectileBallisticThreat [" + threat.Name + "] length is <= 0", Severity.Warning);
}
if (t.Attributes.Mass <= 0)
{
Logger.Instance.AddLogMessage("ProjectileBallisticThreat [" + threat.Name + "] mass is <= 0", Severity.Warning);
}
if (t.Attributes.Speed <= 0)
{
Logger.Instance.AddLogMessage("ProjectileBallisticThreat [" + threat.Name + "] speed is <= 0", Severity.Warning);
}
}
else if (threat is CyPhy.ShapedChargeJetBallisticThreat)
{
CyPhy.ShapedChargeJetBallisticThreat t = threat as CyPhy.ShapedChargeJetBallisticThreat;
if (t.Attributes.Diameter <= 0)
{
Logger.Instance.AddLogMessage("ShapedChargeJetBallisticThreat [" + threat.Name + "] diameter is <= 0", Severity.Warning);
}
if (t.Attributes.Length <= 0)
{
Logger.Instance.AddLogMessage("ShapedChargeJetBallisticThreat [" + threat.Name + "] length is <= 0", Severity.Warning);
}
if (t.Attributes.Mass <= 0)
{
Logger.Instance.AddLogMessage("ShapedChargeJetBallisticThreat [" + threat.Name + "] mass is <= 0", Severity.Warning);
}
if (t.Attributes.Speed <= 0)
{
Logger.Instance.AddLogMessage("ShapedChargeJetBallisticThreat [" + threat.Name + "] speed is <= 0", Severity.Warning);
}
}
}
private CyPhy.Components GetImportFolder(CyPhy.RootFolder rf)
{
CyPhy.Components rtn = null;
foreach (CyPhy.Components c in rf.Children.ComponentsCollection)
{
if (c.Name == ImportedComponentsFolderName)
{
rtn = c;
break;
}
}
if (rtn == null)
{
rtn = CyPhyClasses.Components.Create(rf);
rtn.Name = ImportedComponentsFolderName;
}
return rtn;
}
