/***************************************************/ /**** Private Methods ****/ /***************************************************/ private int DeleteSurfaces(IEnumerable <object> ids) { int success = 1; if (ids != null) { List <int> indicies = ids.Cast <int>().ToList(); foreach (int index in indicies) { IFSurface lusasSurface = d_LusasData.getSurfaceByNumber(index); if (lusasSurface.getHOFs().Count() > 0) { //Engine.Base.Compute.RecordWarning(index + @" has higher order features(HOFs) //and cannot be deleted"); } else { d_LusasData.Delete(lusasSurface); } } } else { d_LusasData.deleteSurfaces(); } return(success); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static Panel ToPanel(this IFSurface lusasSurface, Dictionary <string, Edge> edges, HashSet <string> groupNames, Dictionary <string, ISurfaceProperty> surfaceProperties, Dictionary <string, IMaterialFragment> materials, Dictionary <string, Constraint4DOF> supports, Dictionary <string, MeshSettings2D> meshes) { object[] lusasSurfaceLines = lusasSurface.getLOFs(); List <ICurve> dummyCurve = new List <ICurve>(); int n = lusasSurfaceLines.Length; HashSet <string> tags = new HashSet <string>(IsMemberOf(lusasSurface, groupNames)); List <Edge> surfaceEdges = new List <Edge>(); for (int i = 0; i < n; i++) { Edge edge = GetEdge(lusasSurface, i, edges); surfaceEdges.Add(edge); } Panel panel = Engine.Structure.Create.Panel(surfaceEdges, dummyCurve); panel.Tags = tags; int adapterID = lusasSurface.getID(); panel.SetAdapterId(typeof(LusasId), adapterID); List <string> geometricAssignments = GetAttributeAssignments(lusasSurface, "Geometric"); List <string> materialAssignments = GetAttributeAssignments(lusasSurface, "Material"); IMaterialFragment panelMaterial; ISurfaceProperty surfaceProperty; if (!(geometricAssignments.Count() == 0)) { surfaceProperties.TryGetValue(geometricAssignments[0], out surfaceProperty); if (!(materialAssignments.Count() == 0)) { materials.TryGetValue(materialAssignments[0], out panelMaterial); surfaceProperty.Material = panelMaterial; } panel.Property = surfaceProperty; } MeshSettings2D surfaceMesh; List <string> meshSettings = GetAttributeAssignments(lusasSurface, "Mesh"); if (!(meshSettings.Count() == 0)) { meshes.TryGetValue(meshSettings[0], out surfaceMesh); panel.Fragments.Add(surfaceMesh); } return(panel); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private static Edge GetEdge(IFSurface lusasSurf, int lineIndex, Dictionary <string, Edge> bars) { Edge edge; IFLine lusasEdge = lusasSurf.getLOFs()[lineIndex]; bars.TryGetValue(lusasEdge.getID().ToString(), out edge); return(edge); }
private List <ILoad> ReadAreaUniformTemperatureLoads(List <string> ids = null) { /***************************************************/ /**** Private Methods ****/ /***************************************************/ List <ILoad> areaUniformTemperatureLoads = new List <ILoad>(); object[] lusasTemperatureLoads = d_LusasData.getAttributes("Temperature"); if (!(lusasTemperatureLoads.Count() == 0)) { List <Panel> panelsList = ReadPanels(); Dictionary <string, Panel> panels = panelsList.ToDictionary( x => x.AdapterId <string>(typeof(LusasId))); List <IFLoadcase> allLoadcases = new List <IFLoadcase>(); for (int i = 0; i < lusasTemperatureLoads.Count(); i++) { IFLoading lusasTemperatureLoad = (IFLoading)lusasTemperatureLoads[i]; IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases = GetLoadAssignments(lusasTemperatureLoad); foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases) { List <IFAssignment> surfaceAssignments = new List <IFAssignment>(); foreach (IFAssignment assignment in groupedAssignment) { IFSurface trySurf = assignment.getDatabaseObject() as IFSurface; if (trySurf != null) { surfaceAssignments.Add(assignment); } } List <string> analysisName = new List <string> { lusasTemperatureLoad.getAttributeType() }; if (surfaceAssignments.Count != 0) { AreaUniformTemperatureLoad areaUniformTemperatureLoad = Adapters.Lusas.Convert.ToAreaTempratureLoad( lusasTemperatureLoad, groupedAssignment, panels); areaUniformTemperatureLoad.Tags = new HashSet <string>(analysisName); areaUniformTemperatureLoads.Add(areaUniformTemperatureLoad); } } } } return(areaUniformTemperatureLoads); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private IFSurface CreateSurface(Panel panel) { List <IFLine> edges = new List <IFLine>(); foreach (Edge edge in panel.ExternalEdges) { string edgeId = GetAdapterId <string>(edge); if (string.IsNullOrEmpty(edgeId)) { Engine.Base.Compute.RecordError("Could not find the ids for at least one Edge, Panel not created."); return(null); } else { edges.Add(d_LusasData.getLineByNumber(edgeId)); } } IFSurface lusasSurface = d_LusasData.createSurfaceBy(edges.ToArray()); if (lusasSurface != null) { int adapterIdName = lusasSurface.getID(); panel.SetAdapterId(typeof(LusasId), adapterIdName); if (!(panel.Tags.Count == 0)) { AssignObjectSet(lusasSurface, panel.Tags); } if (CheckPropertyWarning(panel, p => p.Property) && !Engine.Adapters.Lusas.Query.InvalidSurfaceProperty(panel.Property)) { IFAttribute lusasGeometricSurface = d_LusasData.getAttribute("Surface Geometric", panel.Property.AdapterId <int>(typeof(LusasId))); lusasGeometricSurface.assignTo(lusasSurface); if (CheckPropertyWarning(panel, p => p.Property.Material)) { IFAttribute lusasMaterial = d_LusasData.getAttribute("Material", panel.Property.Material.AdapterId <int>(typeof(LusasId))); lusasMaterial.assignTo(lusasSurface); } } if (panel.Fragments.Contains(typeof(MeshSettings2D))) { IFAssignment meshAssignment = m_LusasApplication.newAssignment(); meshAssignment.setAllDefaults(); MeshSettings2D meshSettings2D = panel.FindFragment <MeshSettings2D>(); IFMeshAttr mesh = d_LusasData.getMesh(meshSettings2D.Name); mesh.assignTo(lusasSurface, meshAssignment); } } return(lusasSurface); }
public List <List <double[]> > getSurfaceCoordinatesFromLusas() { IFSelection userInp = lusas.getSelection(); //check if selection is at least one point if (userInp.countSurfaces() < 1) { MessageBox.Show("please select at least one point", "", MessageBoxButtons.OK); return(null); } //create collection to popoulate surfaces List <List <double[]> > surfaces = new List <List <double[]> >(); for (int i = 0; i < userInp.countSurfaces(); i++) { //gereate array of ids List <int> pointIds = new List <int>(); //generate collection for populating vertices List <double[]> vertexes = new List <double[]>(); IFSurface surface = userInp.getSurface(i); object[] lines = surface.getLOFs() as object[]; for (int l = 0; l < lines.Length; l++) { IFLine line = lines[l] as IFLine; object[] points = line.getLOFs() as object[]; for (int k = 0; k < points.Length; k++) { IFPoint point = points[k] as IFPoint; int id = point.getID(); if (!pointIds.Contains(id)) { pointIds.Add(id); double[] position = new double[3]; position[0] = point.getX(); position[1] = point.getY(); position[2] = point.getZ(); //point.getXYZ(position[0],position[1],position[2]); vertexes.Add(position); } } } surfaces.Add(vertexes); } return(surfaces); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private List <Panel> ReadPanels(List <string> ids = null) { object[] lusasSurfaces = d_LusasData.getObjects("Surface"); List <Panel> panels = new List <Panel>(); if (!(lusasSurfaces.Count() == 0)) { IEnumerable <Edge> edgesList = ReadEdges(); Dictionary <string, Edge> edges = edgesList.ToDictionary( x => x.AdapterId <string>(typeof(LusasId))); HashSet <string> groupNames = ReadTags(); IEnumerable <IMaterialFragment> materialList = ReadMaterials(); Dictionary <string, IMaterialFragment> materials = materialList.ToDictionary( x => x.Name.ToString()); IEnumerable <ISurfaceProperty> sectionPropertiesList = Read2DProperties(); Dictionary <string, ISurfaceProperty> sectionProperties = sectionPropertiesList.ToDictionary( x => x.Name.ToString()); IEnumerable <Constraint4DOF> supportsList = Read4DOFConstraints(); Dictionary <string, Constraint4DOF> supports = supportsList.ToDictionary( x => x.Name); List <MeshSettings2D> meshesList = ReadMeshSettings2D(); Dictionary <string, MeshSettings2D> meshes = meshesList.ToDictionary( x => x.Name.ToString()); for (int i = 0; i < lusasSurfaces.Count(); i++) { IFSurface lusasSurface = (IFSurface)lusasSurfaces[i]; Panel panel = Adapters.Lusas.Convert.ToPanel(lusasSurface, edges, groupNames, sectionProperties, materials, supports, meshes); panels.Add(panel); } } return(panels); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private static IEnumerable <IAreaElement> GetSurfaceAssignments(IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Panel> panels) { List <IAreaElement> assignedSurfs = new List <IAreaElement>(); Panel panel; foreach (IFAssignment lusasAssignment in lusasAssignments) { if (lusasAssignment.getDatabaseObject() is IFSurface) { IFSurface lusasSurface = (IFSurface)lusasAssignment.getDatabaseObject(); panels.TryGetValue(lusasSurface.getID().ToString(), out panel); assignedSurfs.Add(panel); } else { AssignmentWarning(lusasAssignment); } } return(assignedSurfs); }
/***************************************************/ private bool CreateCollection(IEnumerable <Panel> panels) { if (panels != null) { CreateTags(panels); List <Panel> validPanels = new List <Panel>(); foreach (Panel panel in panels) { if (panel.ExternalEdges.Count > 0) { if (CheckPropertyError(panel, p => p.ExternalEdges)) { if (CheckPropertyError(panel.ExternalEdges, e => e.Select(x => x.Curve))) { if (panel.ExternalEdges.All(x => x != null) && panel.ExternalEdges.Select(x => x.Curve).All(y => y != null)) { if (panel.Openings.Count > 0) { Engine.Base.Compute.RecordWarning("Lusas_Toolkit does not support Panels with Openings. The Panel will be pushed if valid, the Openings will not be pushed."); } if (panel.ExternalEdges.All(x => !Engine.Adapters.Lusas.Query.InvalidEdge(x))) { if (Engine.Spatial.Query.IsPlanar(panel, false, Tolerance.MacroDistance)) { for (int i = 0; i < panel.ExternalEdges.Count; i++) { if (!CheckPropertyError(panel, p => panel.ExternalEdges[i]) && Engine.Adapters.Lusas.Query.InvalidEdge(panel.ExternalEdges[i])) { break; } if (i == panel.ExternalEdges.Count - 1) { validPanels.Add(panel); } } } else { Engine.Base.Compute.RecordError("The geometry defining the Panel is not Planar, and therefore the Panel will not be created."); } } else { Engine.Base.Compute.RecordError("One or more of the External Edges of the Panel are invalid."); } } else { Engine.Base.Compute.RecordError("One of more of the External Edges of the Panel or Curves defining the External Edges are null."); } } } } else { Engine.Base.Compute.RecordError($"An object of type {panel.GetType().Name} could not be created due to a property of type {typeof(Edge).Name} being null. Please check your input data!"); } } if (validPanels.Any(x => x.Fragments.Contains(typeof(MeshSettings2D)))) { BHoMObjectNameComparer comparer = new BHoMObjectNameComparer(); List <MeshSettings2D> distinctMeshes = panels.Select(x => x.FindFragment <MeshSettings2D>()) .Distinct <MeshSettings2D>(comparer) .ToList(); foreach (MeshSettings2D mesh in distinctMeshes) { CreateMeshSettings2D(mesh); } foreach (Panel validPanel in validPanels) { validPanel.AddFragment(distinctMeshes.First(x => comparer.Equals(x, (validPanel.FindFragment <MeshSettings2D>()))), true); } } ReduceRuntime(true); IFSurface lusasSurface = null; foreach (Panel validPanel in validPanels) { lusasSurface = CreateSurface(validPanel); } ReduceRuntime(false); } return(true); }