private CyPhy.ComponentAssembly CreateComponentAssemblyRoot(avm.Design ad_import) { CyPhy.ComponentAssemblies cyphy_cas; CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder((MgaProject)project); cyphy_cas = rf.Children.ComponentAssembliesCollection.Where(d => d.Name == typeof(CyPhyClasses.ComponentAssemblies).Name).FirstOrDefault(); if (cyphy_cas == null) { cyphy_cas = CyPhyClasses.ComponentAssemblies.Create(rf); cyphy_cas.Name = typeof(CyPhyClasses.ComponentAssemblies).Name; } CyPhy.ComponentAssembly cyphy_container = CyPhyClasses.ComponentAssembly.Create(cyphy_cas); // container.Name = ad_import.Name; RootContainer has a name too // TODO: check ad_import.SchemaVersion int designID; if (int.TryParse(ad_import.DesignID, out designID)) { cyphy_container.Attributes.ID = designID; } if (string.IsNullOrEmpty(ad_import.RootContainer.Description) == false) { cyphy_container.Attributes.Description = ad_import.RootContainer.Description; } return(cyphy_container); }
private static int GetContainingAssemblies(CyPhyML.ComponentAssembly assembly, Dictionary <CyPhyML.DesignElement, int> visited, List <CyPhyML.ComponentAssembly> sorted) { int ordinal; if (visited.TryGetValue(assembly, out ordinal)) { if (ordinal == -1) { throw new Exception(String.Format("Cycle involving {0}", assembly.Name)); } return(ordinal); } visited.Add(assembly, -1); ordinal = 0; foreach (CyPhyML.ComponentRef compref in assembly.ReferencedBy.ComponentRef) { if (compref.ParentContainer is CyPhyML.ComponentAssembly) { ordinal = Math.Max(ordinal, 1 + GetContainingAssemblies(compref.ParentContainer as CyPhyML.ComponentAssembly, visited, sorted)); } } if (assembly.ParentContainer is CyPhyML.ComponentAssembly) { ordinal = Math.Max(ordinal, 1 + GetContainingAssemblies(assembly.ParentContainer as CyPhyML.ComponentAssembly, visited, sorted)); } visited[assembly] = ordinal; sorted.Add(assembly); return(ordinal); }
private void Process(CyPhy.ComponentAssembly componentAssembly) { if (Logger == null) { Logger = new CyPhyGUIs.GMELogger(componentAssembly.Impl.Project, this.ComponentName); } if (String.IsNullOrWhiteSpace(componentAssembly.Attributes.Path)) { componentAssembly.Attributes.Path = GetRandomComponentAssemblyDir(); } else { string originalPath = Path.Combine(componentAssembly.Impl.Project.GetRootDirectoryPath(), componentAssembly.Attributes.Path); componentAssembly.Attributes.Path = GetRandomComponentAssemblyDir(); if (Directory.Exists(originalPath)) { try { CopyDirectory(originalPath, Path.Combine(componentAssembly.Impl.Project.GetRootDirectoryPath(), componentAssembly.Attributes.Path)); } catch (Exception ex) { Logger.WriteError("Exception while copying to {0}: {1}", componentAssembly.Attributes.Path, ex); } } } }
/// <summary> /// Gets ComponentAssemblys that contain component directly, or through references to ComponentAssemblys /// </summary> public static IEnumerable <CyPhyML.ComponentAssembly> GetContainingAssemblies(CyPhyML.Component component) { Queue <CyPhyML.ComponentAssembly> containingAssemblies = new Queue <CyPhyML.ComponentAssembly>(); foreach (CyPhyML.ComponentRef compref in component.ReferencedBy.ComponentRef) { if (compref.ParentContainer is CyPhyML.ComponentAssembly) { containingAssemblies.Enqueue(compref.ParentContainer as CyPhyML.ComponentAssembly); } } while (containingAssemblies.Count > 0) { CyPhyML.ComponentAssembly asm = containingAssemblies.Dequeue(); yield return(asm); foreach (CyPhyML.ComponentRef compref in asm.ReferencedBy.ComponentRef) { if (compref.ParentContainer is CyPhyML.ComponentAssembly) { containingAssemblies.Enqueue(compref.ParentContainer as CyPhyML.ComponentAssembly); } } if (asm.ParentContainer is CyPhyML.ComponentAssembly) { containingAssemblies.Enqueue(asm.ParentContainer as CyPhyML.ComponentAssembly); } } }
// Verify ComponentAssembly model so that it's Meta-Link compatible private bool VerifyAssembly(CyPhyML.ComponentAssembly assembly, List <string> errorList) { // An assembly should only contain component references if (assembly.Children.ComponentCollection.Any()) { foreach (var comp in assembly.Children.ComponentCollection) { errorList.Add("The assembly contains a component:" + comp.Name + ". Meta-Link will only work with references."); } } if (assembly.Children.ComponentAssemblyCollection.Any()) { foreach (var comp in assembly.Children.ComponentCollection) { errorList.Add("The assembly contains a component assembly:" + comp.Name + ". Meta-Link will only work with references."); } } foreach (var cref in assembly.Children.ComponentRefCollection) { if (cref.AllReferred == null) { errorList.Add("The assembly contains a null-reference:" + cref.Name); } } VerifyCADResources(assembly, errorList); return(errorList.Count == 0); }
// Collects all the component references this assembly contains, including multi-level hierarchies public static List <CyPhyML.ComponentRef> CollectComponentRefsRecursive(CyPhyML.ComponentAssembly assembly) { List <CyPhyML.ComponentRef> complist = new List <CyPhyML.ComponentRef>(); CollectComponentRefs(complist, assembly); return(complist); }
// Collects all the components this assembly contains, including multi-level hierarchies public static HashSet <CyPhyML.Component> CollectComponentsRecursive(CyPhyML.ComponentAssembly assembly) { HashSet <CyPhyML.Component> complist = new HashSet <CyPhyML.Component>(); CollectComponents(complist, assembly); return(complist); }
private void PartManufacturingGeneration(CyPhy.ComponentAssembly componentasm) { // [1] Create ManufacturingData // [2] Regenerate manufacturing xml file for each ManufacturingData // [3] Generate manifest file if (this.AVMComponentList == null) { return; } TraverseComponentAssembly(componentasm); //foreach (ComponentManufacturingData data in this.ComponentManufacturingDataList) //{ // data.UpdateManufacturingSpec(); //} // manifest string reportJson = Newtonsoft.Json.JsonConvert.SerializeObject( this.ManufacturingManifestData, Newtonsoft.Json.Formatting.Indented); using (StreamWriter writer = new StreamWriter(Path.Combine(this.OutputDirectory, "manufacturing.manifest.json"))) { writer.WriteLine(reportJson); } }
public void FindComponents(CyPhy.ComponentAssembly cyphyasm, List <CyPhy.Component> regular, List <CyPhy.Component> size2fit) { CheckAssembly(cyphyasm); foreach (var item in cyphyasm.Children.ComponentAssemblyCollection) { FindComponents(item, regular, size2fit); } foreach (var item in cyphyasm.Children.ComponentCollection) { if (CheckComponent(item)) { // size2fit or regular if (item.Children.SizedToFitCollection.Any()) { size2fit.Add(item); } else { regular.Add(item); } } } }
private static void CollectComponents(HashSet <CyPhyML.Component> complist, CyPhyML.ComponentAssembly assembly, HashSet <CyPhyML.ComponentAssembly> visitedComponentAssemblies) { // Get all the components from here foreach (var compref in assembly.Children.ComponentRefCollection) { if (compref.AllReferred is CyPhyML.Component) { complist.Add(compref.AllReferred as CyPhyML.Component); } else if (compref.AllReferred is CyPhyML.ComponentAssembly) { if (visitedComponentAssemblies.Add(compref.AllReferred as CyPhyML.ComponentAssembly) == false) { throw new ApplicationException(String.Format("Cycle involving {0}", compref.AllReferred.Name)); } CollectComponents(complist, compref.AllReferred as CyPhyML.ComponentAssembly, visitedComponentAssemblies); visitedComponentAssemblies.Remove(compref.AllReferred as CyPhyML.ComponentAssembly); } } foreach (var comp in assembly.Children.ComponentCollection) { complist.Add(comp); } foreach (var ca in assembly.Children.ComponentAssemblyCollection) { CollectComponents(complist, ca, visitedComponentAssemblies); } }
private void PrepareMetaLinkData(CyPhy2CAD_CSharp.MetaLinkData data, CyPhyML.ComponentAssembly assembly, String prefix) { Dictionary <string, CyPhyML.ComponentRef> instanceguids = new Dictionary <string, CyPhyML.ComponentRef>(); CyphyMetaLinkUtils.CollectInstanceGUIDs(instanceguids, "", assembly); if (assembly.Children.ComponentCollection.Any()) { GMEConsole.Warning.WriteLine("Assembly contains components, Meta-Link may not work properly on this model."); } //List<CyPhyML.ComponentRef> comps = CyphyMetaLinkUtils.CollectComponentRefsRecursive(assembly); foreach (var item in instanceguids) { CyPhy2CAD_CSharp.MetaLinkData.Component mcomp = new CyPhy2CAD_CSharp.MetaLinkData.Component(); mcomp.ID = item.Key; mcomp.AvmID = (item.Value.AllReferred as CyPhyML.Component).Attributes.AVMID; data.Components.Add(mcomp); foreach (CyPhyML.Connector conn in (item.Value.AllReferred as CyPhyML.Component).Children.ConnectorCollection) { CyPhy2CAD_CSharp.MetaLinkData.Connector mconn = new CyPhy2CAD_CSharp.MetaLinkData.Connector(); mconn.ID = conn.Guid.ToString(); mconn.DisplayName = conn.Name; mcomp.Connectors.Add(mconn); foreach (CyPhyML.CADDatum d in conn.Children.CADDatumCollection) { CyPhy2CAD_CSharp.MetaLinkData.Datum md = new CyPhy2CAD_CSharp.MetaLinkData.Datum(); md.ID = d.Guid.ToString(); md.DisplayName = d.Name; mconn.Datums.Add(md); } } } }
/// <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; } }
/// <summary> /// Meta-Link feature: If there's no components in an assembly still need to add one empty root component /// </summary> /// <param name="?"></param> public void AddRootComponent(CyPhy.ComponentAssembly assembly) { CADAssembly a = new CADAssembly(); a.Id = a.ConfigID = assembly.Guid.ToString(); a.Name = a.DisplayName = assembly.Name; assemblies.Add(UtilityHelpers.CleanString2(assembly.Name), a); }
private void VerifyCADResources(CyPhyML.ComponentAssembly assembly, List <string> errorList) { var componentlist = CyphyMetaLinkUtils.CollectComponentsRecursive(assembly); foreach (var component in componentlist) { VerifyCADResources(component, errorList); } }
public CommonTraversal(CyPhy.ConnectorComposition connection, CyPhy.ComponentAssembly topassembly) { Initialize(); startNodeID = ""; this.topAssembly = topassembly; VisitConnectorComposition(connection); }
public void FindTopLevelPort(CyPhy.ComponentAssembly topAssembly) { return; /* * CyPhy.KinematicJoint joint = CyphyJoint; * string id = null; * while (true) * { * if (joint.DstConnections.JointCompositionCollection.Any()) * { * if (joint.DstConnections.JointCompositionCollection.First().DstEnds.KinematicJoint == null) * { * id = joint.Name; * } * else * { * joint = joint.DstConnections.JointCompositionCollection.First().DstEnds.KinematicJoint; * } * } * else * { * if (joint != CyphyJoint && joint.ParentContainer.Guid == topAssembly.Guid) * id = joint.Name; * break; * } * } * if (id == null) * { * while (true) * { * if (joint.SrcConnections.JointCompositionCollection.Any()) * { * if (joint.SrcConnections.JointCompositionCollection.First().SrcEnds.KinematicJoint == null) * { * id = joint.Name; * break; * } * else * { * joint = joint.SrcConnections.JointCompositionCollection.First().SrcEnds.KinematicJoint; * } * } * else * { * if (joint != CyphyJoint && joint.ParentContainer.Guid == topAssembly.Guid) * id = joint.Name; * break; * } * } * } * * this.TopLevelID = id; */ }
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); ProcessReferenceCoordinateSystems(cyphyasm); }
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(); } }
public void ProcessReferenceCoordinateSystems(CyPhy.ComponentAssembly cyphyasm) { if (cyphyasm != null) { // [4] Find ReferenceCoordinateComponents foreach (CyPhy.ReferenceCoordinateSystem refCoord in cyphyasm.Children.ReferenceCoordinateSystemCollection) { ReferenceCoordinateSystemTraversal traverser = new ReferenceCoordinateSystemTraversal(refCoord); referenceCoordComponents.AddRange(traverser.referenceCoordComponents); } } }
public AbstractClasses.Design ParseCyPhyDesign(CyPhy.ComponentAssembly componentAssembly) { AbstractClasses.Design design = new AbstractClasses.Design() { Name = componentAssembly.Name, ID = componentAssembly.Attributes.ID.ToString() }; design.TopContainer = ParseCyPhyComponentAssembly(componentAssembly); return(design); }
private void Visit(CyPhyInterfaces.ComponentAssembly componentAssembly) { foreach (var innerComponentAssembly in componentAssembly.Children.ComponentAssemblyCollection) { Visit(componentAssembly); } foreach (var component in componentAssembly.Children.ComponentCollection) { Visit(component); } }
public override void Expand(CyPhy.ComponentAssembly configuration) { this.Configuration = configuration; if (this.OriginalSystemUnderTest == null) { // don't need to do anything } else 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); } }
/// <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 override void Expand(CyPhy.ComponentAssembly configuration) { this.Configuration = configuration; // FIXME: this test should be repaired. It does not work correctly if TBs have different SUTs. Be safe and make a copy always // if (this.OriginalSystemUnderTest.Referred.DesignEntity.ID == configuration.ID) if (false) { this.expandedParametricExploration = this.parametricExploration; } else { // create temp folder for parametric exploration CyPhy.ParametricExplorationFolder testing = CyPhyClasses.ParametricExplorationFolder.Cast(this.parametricExploration.ParentContainer.Impl); var tempFolderName = AnalysisModelProcessor.GetTemporaryFolderName(this.parametricExploration.Impl); CyPhy.ParametricExplorationFolder tempFolder = testing.Children.ParametricExplorationFolderCollection.FirstOrDefault(x => x.Name == tempFolderName); if (tempFolder == null) { tempFolder = CyPhyClasses.ParametricExplorationFolder.Create(testing); tempFolder.Name = tempFolderName; this.AddToTraceabilityAndTemporary(tempFolder.Impl, testing.Impl, recursive: false); } // copy parametric exploration var tempCopy = (tempFolder.Impl as MgaFolder).CopyFCODisp(this.parametricExploration.Impl as MgaFCO); // fix name tempCopy.Name = AnalysisModelProcessor.GetTemporaryObjectName(this.parametricExploration.Impl, configuration.Impl); this.AddToTraceabilityAndTemporary(tempCopy, this.parametricExploration.Impl); // set expanded property to the expanded element this.expandedParametricExploration = CyPhyClasses.ParametricExploration.Cast(tempCopy); } // expand all test benches foreach (var testBenchRef in this.expandedParametricExploration.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); } }
private CyPhyML.ComponentAssembly FindTopLevelAssembly(GmeCommon.Interfaces.FCO componentasm) { CyPhyML.ComponentAssembly topassembly = null; if (componentasm.ParentContainer.Kind == "ComponentAssemblies") // Top Level Assembly { topassembly = (componentasm as CyPhyML.ComponentAssembly); } else if (componentasm.ParentContainer.Kind == "ComponentAssembly") { topassembly = FindTopLevelAssembly(componentasm.ParentContainer as CyPhyML.ComponentAssembly); } return(topassembly); }
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); }
public void StartAssemblySync(MgaProject project, MgaFCO currentobj, int param) { // FIXME: possible race between sending MetaLink Bridge INTEREST and it registering it, and Creo sending its INTEREST // n.b. the tests call StartAssemblySync directly metalinkAddon.assemblySyncPaused = false; ProjectDirectory = Path.GetDirectoryName(project.ProjectConnStr.Substring("MGA=".Length)); if (ConnectToMetaLinkBridgeTask == null) { ConnectToMetaLinkBridge(project, param); } metalinkAddon.Enable(true); CyPhyML.ComponentAssembly topasm = null; MgaGateway.PerformInTransaction(delegate { topasm = Run(project, currentobj, param); if (topasm != null) { metalinkAddon.AssemblyID = topasm.Guid.ToString(); } }); ConnectToMetaLinkBridgeTask.Wait(); if (ConnectToMetaLinkBridgeTask.Result == false) { return; } if (topasm == null) { metalinkAddon.AssemblyID = null; GMEConsole.Error.WriteLine("No top level assembly can be found. Open an assembly and try again."); return; } try { metalinkAddon.CallCyPhy2CADWithTransaction(project, (topasm.Impl as MgaFCO), param); } catch (Exception e) { metalinkAddon.syncedComponents.Remove(metalinkAddon.AssemblyID); // FIXME: propagateAddon.LastStartedInstance.Remove metalinkAddon.AssemblyID = null; GMEConsole.Error.Write(e.Message); } }
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 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); } }
private void ManufacturingGeneration(MgaFCO currentobj) { if (currentobj.MetaBase.Name == "TestBench") { // DDP Generation CyPhy.TestBench tb = CyPhyClasses.TestBench.Cast(currentobj); var catlsut = tb.Children.ComponentAssemblyCollection.FirstOrDefault(); // should be an instance b/c elaborate was called earlier if (catlsut == null) { throw new Exception("There is no elaborated system under test component assembly in the model!"); } var design = CyPhy2DesignInterchange.CyPhy2DesignInterchange.Convert(catlsut); this.TestBenchName = tb.Name; this.AssemblyName = design.Name; design.SaveToFile(Path.Combine(this.OutputDirectory, this.TestBenchName + ".adm")); if (catlsut.Attributes.ConfigurationUniqueID.Contains("{")) { this.ManufacturingManifestData.DesignID = catlsut.Attributes.ConfigurationUniqueID; } else { this.ManufacturingManifestData.DesignID = "{" + catlsut.Attributes.ConfigurationUniqueID + "}"; } this.ManufacturingManifestData.Name = catlsut.Name; PartManufacturingGeneration(catlsut); } else if (currentobj.MetaBase.Name == "ComponentAssembly") { // DDP Generation CyPhy.ComponentAssembly assembly = CyPhyClasses.ComponentAssembly.Cast(currentobj); var design = CyPhy2DesignInterchange.CyPhy2DesignInterchange.Convert(assembly); this.AssemblyName = design.Name; this.TestBenchName = design.Name; design.SaveToFile(Path.Combine(this.OutputDirectory, this.TestBenchName + ".adm")); this.ManufacturingManifestData.DesignID = "{" + assembly.Attributes.ConfigurationUniqueID + "}"; this.ManufacturingManifestData.Name = assembly.Name; PartManufacturingGeneration(assembly); } else { throw new NotImplementedException(); } }