/***************************************************/ /**** Private Methods ****/ /***************************************************/ private IFLoadingBody CreateGravityLoad(GravityLoad gravityLoad, IFGeometry[] lusasGeometry) { IFLoadingBody lusasGravityLoad; IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(gravityLoad.Loadcase.AdapterId <int>(typeof(LusasId))); if (d_LusasData.existsAttribute("Loading", gravityLoad.Name)) { lusasGravityLoad = (IFLoadingBody)d_LusasData.getAttributes("Loading", gravityLoad.Name); } else { lusasGravityLoad = d_LusasData.createLoadingBody(gravityLoad.Name); lusasGravityLoad.setBody(gravityLoad.GravityDirection.X, gravityLoad.GravityDirection.Y, gravityLoad.GravityDirection.Z); } IFAssignment lusasAssignment = m_LusasApplication.assignment(); lusasAssignment.setLoadset(assignedLoadcase); lusasGravityLoad.assignTo(lusasGeometry, lusasAssignment); int adapterIdName = lusasGravityLoad.getID(); gravityLoad.SetAdapterId(typeof(LusasId), adapterIdName); return(lusasGravityLoad); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static GravityLoad ToGravityLoad(IFLoading lusasGravityLoad, IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Node> nodes, Dictionary <string, Bar> bars, Dictionary <string, Panel> panels) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); Vector gravityVector = new Vector { X = lusasGravityLoad.getValue("accX"), Y = lusasGravityLoad.getValue("accY"), Z = lusasGravityLoad.getValue("accZ") }; IEnumerable <BHoMObject> assignedObjects = GetGeometryAssignments( lusasAssignments, nodes, bars, panels); GravityLoad gravityLoad = Engine.Structure.Create.GravityLoad( loadcase, gravityVector, assignedObjects, GetName(lusasGravityLoad)); int adapterNameId = lusasGravityLoad.getID(); gravityLoad.SetAdapterId(typeof(LusasId), adapterNameId); return(gravityLoad); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static PointDisplacement ToPointDisplacement(IFLoading lusasPrescribedDisplacement, IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Node> nodes) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); IEnumerable <Node> assignedNodes = GetPointAssignments(lusasAssignments, nodes); Vector translationVector = new Vector { X = lusasPrescribedDisplacement.getValue("U"), Y = lusasPrescribedDisplacement.getValue("V"), Z = lusasPrescribedDisplacement.getValue("W") }; Vector rotationVector = new Vector { X = lusasPrescribedDisplacement.getValue("THX"), Y = lusasPrescribedDisplacement.getValue("THY"), Z = lusasPrescribedDisplacement.getValue("THZ") }; PointDisplacement pointDisplacement = BH.Engine.Structure.Create.PointDisplacement( loadcase, assignedNodes, translationVector, rotationVector, LoadAxis.Global, GetName(lusasPrescribedDisplacement)); int adapterNameId = lusasPrescribedDisplacement.getID(); pointDisplacement.SetAdapterId(typeof(LusasId), adapterNameId); // Needs to be a bit here that determines whether it is global or local - actually this cannot be done as the //attribute is applied to a group, and within the group the axis could local or global return(pointDisplacement); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static AreaUniformTemperatureLoad ToAreaTempratureLoad( IFLoading lusasTemperatureLoad, IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Panel> panels) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); double temperatureChange = lusasTemperatureLoad.getValue("T") - lusasTemperatureLoad.getValue("T0"); IEnumerable <IAreaElement> assignedPanels = GetSurfaceAssignments(lusasAssignments, panels); AreaUniformTemperatureLoad AreaUniformTemperatureLoad = BH.Engine.Structure.Create.AreaUniformTemperatureLoad( loadcase, temperatureChange, assignedPanels, LoadAxis.Local, false, GetName(lusasTemperatureLoad)); int adapterNameId = lusasTemperatureLoad.getID(); AreaUniformTemperatureLoad.SetAdapterId(typeof(LusasId), adapterNameId); return(AreaUniformTemperatureLoad); }
/***************************************************/ private IFLoadingGlobalDistributed CreateGlobalDistributed(string lusasName, string type, IFLoadcase assignedLoadcase, Vector force, Vector moment, object[] lusasGeometry) { IFLoadingGlobalDistributed lusasGlobalDistributed; if (d_LusasData.existsAttribute("Loading", lusasName)) { lusasGlobalDistributed = (IFLoadingGlobalDistributed)d_LusasData.getAttribute("Loading", lusasName); } else { lusasGlobalDistributed = d_LusasData.createLoadingGlobalDistributed(lusasName); if (type == "Length") { lusasGlobalDistributed.setGlobalDistributed(type, force.X, force.Y, force.Z, moment.X, moment.Y, moment.Z); } else if (type == "Area") { lusasGlobalDistributed.setGlobalDistributed(type, force.X, force.Y, force.Z); } } IFAssignment lusasAssignment = m_LusasApplication.assignment(); lusasAssignment.setLoadset(assignedLoadcase); lusasGlobalDistributed.assignTo(lusasGeometry, lusasAssignment); return(lusasGlobalDistributed); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static BarUniformTemperatureLoad ToBarUniformTemperatureLoad( IFLoading lusasTemperatureLoad, IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Bar> bars) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); double temperatureChange = lusasTemperatureLoad.getValue("T") - lusasTemperatureLoad.getValue("T0"); IEnumerable <Bar> assignedBars = GetLineAssignments(lusasAssignments, bars); BarUniformTemperatureLoad barUniformTemperatureLoad = Engine.Structure.Create.BarUniformTemperatureLoad( loadcase, temperatureChange, assignedBars, LoadAxis.Local, false, GetName(lusasTemperatureLoad)); int adapterNameId = lusasTemperatureLoad.getID(); barUniformTemperatureLoad.SetAdapterId(typeof(LusasId), adapterNameId); return(barUniformTemperatureLoad); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private IFLoadingConcentrated CreateConcentratedLoad(PointLoad pointLoad, object[] lusasPoints) { IFLoadingConcentrated lusasPointLoad; IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(pointLoad.Loadcase.AdapterId <int>(typeof(LusasId))); if (d_LusasData.existsAttribute("Loading", pointLoad.Name)) { lusasPointLoad = (IFLoadingConcentrated)d_LusasData.getAttribute("Loading", pointLoad.Name); } else { lusasPointLoad = d_LusasData.createLoadingConcentrated(pointLoad.Name); lusasPointLoad.setConcentrated( pointLoad.Force.X, pointLoad.Force.Y, pointLoad.Force.Z, pointLoad.Moment.X, pointLoad.Moment.Y, pointLoad.Moment.Z); } IFAssignment lusasAssignment = m_LusasApplication.assignment(); lusasAssignment.setLoadset(assignedLoadcase); lusasPointLoad.assignTo(lusasPoints, lusasAssignment); int adapterIdName = lusasPointLoad.getID(); pointLoad.SetAdapterId(typeof(LusasId), adapterIdName); return(lusasPointLoad); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private IFPrescribedDisplacementLoad CreatePrescribedDisplacement(PointDisplacement pointDisplacement, object[] lusasPoints) { IFPrescribedDisplacementLoad lusasPrescribedDisplacement; IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(pointDisplacement.Loadcase.AdapterId <int>(typeof(LusasId))); if (d_LusasData.existsAttribute("Loading", pointDisplacement.Name)) { lusasPrescribedDisplacement = (IFPrescribedDisplacementLoad)d_LusasData.getAttribute("Loading", pointDisplacement.Name); } else { List <string> valueNames = new List <string> { "u", "v", "w", "thx", "thy", "thz" }; List <string> boolCheck = new List <string> { "haveDispX", "haveDispY", "haveDispZ", "haveRotX", "haveRotY", "haveRotZ" }; List <double> displacements = new List <double> { pointDisplacement.Translation.X, pointDisplacement.Translation.Y, pointDisplacement.Translation.Z, pointDisplacement.Rotation.X, pointDisplacement.Rotation.Y, pointDisplacement.Rotation.Z }; lusasPrescribedDisplacement = d_LusasData.createPrescribedDisplacementLoad( pointDisplacement.Name, "Total"); for (int i = 0; i < valueNames.Count(); i++) { if (!(displacements[i] == 0)) { lusasPrescribedDisplacement.setValue(boolCheck[i], true); lusasPrescribedDisplacement.setValue(valueNames[i], displacements[i]); } else { lusasPrescribedDisplacement.setValue(boolCheck[i], false); } } } IFAssignment lusasAssignment = m_LusasApplication.assignment(); lusasAssignment.setLoadset(assignedLoadcase); lusasPrescribedDisplacement.assignTo(lusasPoints, lusasAssignment); int adapterIdName = lusasPrescribedDisplacement.getID(); pointDisplacement.SetAdapterId(typeof(LusasId), adapterIdName); return(lusasPrescribedDisplacement); }
/***************************************************/ private IFLoadingGlobalDistributed CreateGlobalDistributedLoadSurface(AreaUniformlyDistributedLoad distributedLoad, object[] lusasSurfaces) { IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(distributedLoad.Loadcase.AdapterId <int>(typeof(LusasId))); IFLoadingGlobalDistributed lusasGlobalDistributed = CreateGlobalDistributed(distributedLoad.Name, "Area", assignedLoadcase, distributedLoad.Pressure, null, lusasSurfaces); int adapterIdName = lusasGlobalDistributed.getID(); distributedLoad.SetAdapterId(typeof(LusasId), adapterIdName); return(lusasGlobalDistributed); }
/***************************************************/ private IFLoadingLocalDistributed CreateLocalDistributedLine(BarUniformlyDistributedLoad distributedLoad, object[] lusasLines) { IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(distributedLoad.Loadcase.AdapterId <int>(typeof(LusasId))); IFLoadingLocalDistributed lusasLocalDistributed = CreateLocalDistributed(distributedLoad.Name, "Line", assignedLoadcase, distributedLoad.Force, lusasLines); int adapterIdName = lusasLocalDistributed.getID(); distributedLoad.SetAdapterId(typeof(LusasId), adapterIdName); return(lusasLocalDistributed); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static BarUniformlyDistributedLoad ToBarUniformlyDistributed(IFLoading lusasDistributed, IEnumerable<IFAssignment> lusasAssignments, Dictionary<string, Bar> bars) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); IEnumerable<Bar> assignedBars = GetLineAssignments(lusasAssignments, bars); Vector forceVector = new Vector { X = lusasDistributed.getValue("WX"), Y = lusasDistributed.getValue("WY"), Z = lusasDistributed.getValue("WZ") }; BarUniformlyDistributedLoad barUniformlyDistributed = null; if (lusasDistributed.getAttributeType() == "Global Distributed Load") { Vector momentVector = new Vector { X = lusasDistributed.getValue("MX"), Y = lusasDistributed.getValue("MY"), Z = lusasDistributed.getValue("MZ") }; barUniformlyDistributed = Engine.Structure.Create.BarUniformlyDistributedLoad( loadcase, assignedBars, forceVector, momentVector, LoadAxis.Global, true, GetName(lusasDistributed)); } else if (lusasDistributed.getAttributeType() == "Distributed Load") { barUniformlyDistributed = Engine.Structure.Create.BarUniformlyDistributedLoad( loadcase, assignedBars, forceVector, null, LoadAxis.Local, true, GetName(lusasDistributed)); } int adapterNameId = lusasDistributed.getID(); barUniformlyDistributed.SetAdapterId(typeof(LusasId), adapterNameId); return barUniformlyDistributed; }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private IFLoadingTemperature CreateBarUniformTemperatureLoad(BarUniformTemperatureLoad temperatureLoad, object[] lusasLines) { IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(temperatureLoad.Loadcase.AdapterId <int>(typeof(LusasId))); IFLoadingTemperature lusasTemperatureLoad = CreateTemperatureLoad( temperatureLoad.Name, temperatureLoad.TemperatureChange, lusasLines, assignedLoadcase); int adapterIdName = lusasTemperatureLoad.getID(); temperatureLoad.SetAdapterId(typeof(LusasId), adapterIdName); return(lusasTemperatureLoad); }
/***************************************************/ private bool CreateCollection(IEnumerable <Loadcase> loadcases) { foreach (Loadcase loadcase in loadcases) { IFLoadcase lusasLoadcase = CreateLoadcase(loadcase); if (lusasLoadcase == null) { return(false); } } return(true); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static Loadcase ToLoadcase(this IFLoadcase lusasLoadcase) { Loadcase loadcase = new Loadcase { Name = GetName(lusasLoadcase), Number = lusasLoadcase.getID() }; int adapterNameId = lusasLoadcase.getID(); loadcase.SetAdapterId(typeof(LusasId), adapterNameId); return(loadcase); }
/***************************************************/ internal static string GetName(IFLoadcase lusasLoadcase) { string loadcaseName = ""; if (lusasLoadcase.getName().Contains("/")) { loadcaseName = lusasLoadcase.getName().Substring( lusasLoadcase.getName().LastIndexOf("/") + 1); } else { loadcaseName = lusasLoadcase.getName(); } return(loadcaseName); }
/***************************************************/ internal static int GetAdapterID(IFLoadcase lusasLoadcase, char lastCharacter) { int adapterID = 0; lusasLoadcase.getName(); if (lusasLoadcase.getName().Contains("/")) { adapterID = int.Parse(lusasLoadcase.getName().Split(lastCharacter, '/')[1]); } else { adapterID = lusasLoadcase.getID(); } return(adapterID); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static AreaUniformlyDistributedLoad ToAreaUniformlyDistributed( IFLoading lusasDistributed, IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Panel> panels) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); IEnumerable <IAreaElement> assignedPanels = GetSurfaceAssignments( lusasAssignments, panels); Vector pressureVector = new Vector { X = lusasDistributed.getValue("WX"), Y = lusasDistributed.getValue("WY"), Z = lusasDistributed.getValue("WZ") }; AreaUniformlyDistributedLoad areaUniformlyDistributedLoad = null; if (lusasDistributed.getAttributeType() == "Global Distributed Load") { areaUniformlyDistributedLoad = Engine.Structure.Create.AreaUniformlyDistributedLoad( loadcase, pressureVector, assignedPanels, LoadAxis.Global, true, GetName(lusasDistributed)); } else if (lusasDistributed.getAttributeType() == "Distributed Load") { areaUniformlyDistributedLoad = Engine.Structure.Create.AreaUniformlyDistributedLoad( loadcase, pressureVector, assignedPanels, LoadAxis.Local, true, GetName(lusasDistributed)); } int adapterNameId = lusasDistributed.getID(); areaUniformlyDistributedLoad.SetAdapterId(typeof(LusasId), adapterNameId); return(areaUniformlyDistributedLoad); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private List <Loadcase> ReadLoadcases(List <string> ids = null) { List <Loadcase> loadcases = new List <Loadcase>(); object[] allLoadcases = d_LusasData.getLoadsets("loadcase", "all"); for (int i = 0; i < allLoadcases.Count(); i++) { IFLoadcase lusasLoadcase = (IFLoadcase)allLoadcases[i]; Loadcase loadcase = Adapters.Lusas.Convert.ToLoadcase(lusasLoadcase); List <string> analysisName = new List <string> { lusasLoadcase.getAnalysis().getName() }; loadcase.Tags = new HashSet <string>(analysisName); loadcases.Add(loadcase); } return(loadcases); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static BarPointLoad ToBarPointLoad(IFLoading lusasBarPointLoad, IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Bar> bars) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); IEnumerable <Bar> assignedBars = GetLineAssignments(lusasAssignments, bars); Vector forceVector = new Vector { X = lusasBarPointLoad.getValue("PX"), Y = lusasBarPointLoad.getValue("PY"), Z = lusasBarPointLoad.getValue("PZ") }; Vector momentVector = new Vector { X = lusasBarPointLoad.getValue("MX"), Y = lusasBarPointLoad.getValue("MY"), Z = lusasBarPointLoad.getValue("MZ") }; double forcePosition = lusasBarPointLoad.getValue("Distance"); BarPointLoad barPointLoad; barPointLoad = Engine.Structure.Create.BarPointLoad( loadcase, forcePosition, assignedBars, forceVector, momentVector, LoadAxis.Global, GetName(lusasBarPointLoad)); int adapterNameId = lusasBarPointLoad.getID(); barPointLoad.SetAdapterId(typeof(LusasId), adapterNameId); return(barPointLoad); }
/***************************************************/ private IFLoadingLocalDistributed CreateLocalDistributed(string lusasName, string type, IFLoadcase assignedLoadcase, Vector force, object[] lusasGeometry) { IFLoadingLocalDistributed lusasLocalDistributed; if (d_LusasData.existsAttribute("Loading", lusasName)) { lusasLocalDistributed = (IFLoadingLocalDistributed)d_LusasData.getAttribute("Loading", lusasName); } else { lusasLocalDistributed = d_LusasData.createLoadingLocalDistributed(lusasName); lusasLocalDistributed.setLocalDistributed(force.X, force.Y, force.Z, type); } IFAssignment lusasAssignment = m_LusasApplication.assignment(); lusasAssignment.setLoadset(assignedLoadcase); lusasLocalDistributed.assignTo(lusasGeometry, lusasAssignment); return(lusasLocalDistributed); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static PointLoad ToPointLoad( IFLoading lusasPointLoad, IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Node> nodes) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); IEnumerable <Node> assignedNodes = GetPointAssignments(lusasAssignments, nodes); Vector forceVector = new Vector { X = lusasPointLoad.getValue("px"), Y = lusasPointLoad.getValue("py"), Z = lusasPointLoad.getValue("pz") }; Vector momentVector = new Vector { X = lusasPointLoad.getValue("mx"), Y = lusasPointLoad.getValue("my"), Z = lusasPointLoad.getValue("mz") }; PointLoad pointLoad = Engine.Structure.Create.PointLoad( loadcase, assignedNodes, forceVector, momentVector, LoadAxis.Global, GetName(lusasPointLoad)); int adapterNameId = lusasPointLoad.getID(); pointLoad.SetAdapterId(typeof(LusasId), adapterNameId); return(pointLoad); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private IFLoadingBeamPoint CreateBarPointLoad(BarPointLoad barPointLoad, object[] lusasLines) { IFLoadingBeamPoint lusasBarPointLoad; IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(barPointLoad.Loadcase.AdapterId <int>(typeof(LusasId))); if (d_LusasData.existsAttribute("Loading", barPointLoad.Name)) { lusasBarPointLoad = (IFLoadingBeamPoint)d_LusasData.getAttribute("Loading", barPointLoad.Name); } else { lusasBarPointLoad = d_LusasData.createLoadingBeamPoint(barPointLoad.Name); if (barPointLoad.Axis.ToString() == "Global") { lusasBarPointLoad.setBeamPoint("parametric", "global", "beam"); } else { lusasBarPointLoad.setBeamPoint("parametric", "local", "beam"); } lusasBarPointLoad.addRow( barPointLoad.DistanceFromA, barPointLoad.Force.X, barPointLoad.Force.Y, barPointLoad.Force.Z, barPointLoad.Moment.X, barPointLoad.Moment.Y, barPointLoad.Moment.Z); } IFAssignment lusasAssignment = m_LusasApplication.assignment(); lusasAssignment.setLoadset(assignedLoadcase); lusasBarPointLoad.assignTo(lusasLines, lusasAssignment); int adapterIdName = lusasBarPointLoad.getID(); barPointLoad.SetAdapterId(typeof(LusasId), adapterIdName); return(lusasBarPointLoad); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static BarVaryingDistributedLoad ToBarDistributedLoad(IFLoading lusasBarDistributedLoad, IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Bar> bars) { IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset(); Loadcase loadcase = ToLoadcase(assignedLoadcase); IEnumerable <Bar> assignedBars = GetLineAssignments(lusasAssignments, bars); Vector startForceVector = new Vector { X = lusasBarDistributedLoad.getValue("startpx"), Y = lusasBarDistributedLoad.getValue("startpy"), Z = lusasBarDistributedLoad.getValue("startpz") }; Vector endForceVector = new Vector { X = lusasBarDistributedLoad.getValue("endpx"), Y = lusasBarDistributedLoad.getValue("endpy"), Z = lusasBarDistributedLoad.getValue("endpz") }; Vector startMomentVector = new Vector { X = lusasBarDistributedLoad.getValue("startmx"), Y = lusasBarDistributedLoad.getValue("startmy"), Z = lusasBarDistributedLoad.getValue("startmz") }; Vector endMomentVector = new Vector { X = lusasBarDistributedLoad.getValue("endmx"), Y = lusasBarDistributedLoad.getValue("endmy"), Z = lusasBarDistributedLoad.getValue("endmz") }; double startPosition = lusasBarDistributedLoad.getValue("startDistance"); double endPosition = lusasBarDistributedLoad.getValue("endDistance"); bool relativePositions = lusasBarDistributedLoad.getValue("Type") == "Parametric" ? true : false; LoadAxis axis = LoadAxis.Global; bool projected = false; BH.Engine.Base.Compute.RecordWarning("All BarVaryingDistributedLoads pulled from Lusas are assumed to be in global coordinates and to not be projected."); BarVaryingDistributedLoad barVarDistributedLoad; barVarDistributedLoad = Engine.Structure.Create.BarVaryingDistributedLoad( loadcase, assignedBars, startPosition, startForceVector, startMomentVector, endPosition, endForceVector, endMomentVector, relativePositions, axis, projected, GetName(lusasBarDistributedLoad)); if (barVarDistributedLoad == null) { return(null); } int adapterNameId = lusasBarDistributedLoad.getID(); barVarDistributedLoad.SetAdapterId(typeof(LusasId), adapterNameId); return(barVarDistributedLoad); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private List <IFLoadingBeamDistributed> CreateBarDistributedLoad( BarVaryingDistributedLoad barDistributedLoad, object[] lusasLines) { List <IFLoadingBeamDistributed> lusasBarDistributedLoads = new List <IFLoadingBeamDistributed>(); IFAssignment lusasAssignment = m_LusasApplication.assignment(); IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(barDistributedLoad.Loadcase.AdapterId <int>(typeof(LusasId))); Engine.Base.Compute.RecordWarning( barDistributedLoad.GetType().ToString() + " uses parametric distances in the Lusas_Toolkit" ); List <double> valuesAtA = new List <double> { barDistributedLoad.ForceAtStart.X, barDistributedLoad.ForceAtStart.Y, barDistributedLoad.ForceAtStart.Z, barDistributedLoad.MomentAtStart.X, barDistributedLoad.MomentAtStart.Y, barDistributedLoad.MomentAtStart.Z }; List <double> valuesAtB = new List <double> { barDistributedLoad.ForceAtEnd.X, barDistributedLoad.ForceAtEnd.Y, barDistributedLoad.ForceAtEnd.Z, barDistributedLoad.MomentAtEnd.X, barDistributedLoad.MomentAtEnd.Y, barDistributedLoad.MomentAtEnd.Z }; List <string> keys = new List <string>() { "FX", "FY", "FZ", "MX", "MY", "MZ" }; List <int> ids = new List <int>(); string positioning = barDistributedLoad.RelativePositions ? "parametric" : "actual"; string axis; if (barDistributedLoad.Projected) { axis = "projected"; if (barDistributedLoad.RelativePositions) { Engine.Base.Compute.RecordError("Projected loads with parametric distances are not supported in Lusas."); return(null); } } else { axis = barDistributedLoad.Axis == LoadAxis.Global ? "global" : "local"; } for (int i = 0; i < valuesAtA.Count(); i++) { double valueAtA = valuesAtA[i]; double valueAtB = valuesAtB[i]; if ((valueAtA != 0) || (valueAtB != 0)) { IFLoadingBeamDistributed lusasBarDistributedLoad; if (d_LusasData.existsAttribute("Loading", barDistributedLoad.Name + keys[i])) { lusasBarDistributedLoad = (IFLoadingBeamDistributed)d_LusasData.getAttribute("Loading", barDistributedLoad.Name + keys[i]); lusasBarDistributedLoads.Add(lusasBarDistributedLoad); } else { lusasBarDistributedLoad = d_LusasData.createLoadingBeamDistributed(barDistributedLoad.Name + keys[i]); lusasBarDistributedLoad.setBeamDistributed(positioning, axis, "beam"); switch (keys[i]) { case "FX": lusasBarDistributedLoad.addRow( barDistributedLoad.StartPosition, valueAtA, 0, 0, 0, 0, 0, barDistributedLoad.EndPosition, valueAtB, 0, 0, 0, 0, 0); lusasBarDistributedLoads.Add(lusasBarDistributedLoad); lusasAssignment.setLoadset(assignedLoadcase); lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment); break; case "FY": lusasBarDistributedLoad.addRow( barDistributedLoad.StartPosition, 0, valueAtA, 0, 0, 0, 0, barDistributedLoad.EndPosition, 0, valueAtB, 0, 0, 0, 0); lusasBarDistributedLoads.Add(lusasBarDistributedLoad); lusasAssignment.setLoadset(assignedLoadcase); lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment); break; case "FZ": lusasBarDistributedLoad.addRow( barDistributedLoad.StartPosition, 0, 0, valueAtA, 0, 0, 0, barDistributedLoad.EndPosition, 0, 0, valueAtB, 0, 0, 0); lusasBarDistributedLoads.Add(lusasBarDistributedLoad); lusasAssignment.setLoadset(assignedLoadcase); lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment); break; case "MX": lusasBarDistributedLoad.addRow( barDistributedLoad.StartPosition, 0, 0, 0, valueAtA, 0, 0, barDistributedLoad.EndPosition, 0, 0, 0, valueAtB, 0, 0); lusasBarDistributedLoads.Add(lusasBarDistributedLoad); lusasAssignment.setLoadset(assignedLoadcase); if (barDistributedLoad.Projected || barDistributedLoad.Axis == LoadAxis.Global) { Engine.Base.Compute.RecordWarning("Lusas does not support internal distributed moments in the global axis or as projected loads."); } lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment); break; case "MY": lusasBarDistributedLoad.addRow( barDistributedLoad.StartPosition, 0, 0, 0, 0, valueAtA, 0, barDistributedLoad.EndPosition, 0, 0, 0, 0, valueAtB, 0); lusasBarDistributedLoads.Add(lusasBarDistributedLoad); lusasAssignment.setLoadset(assignedLoadcase); lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment); break; case "MZ": lusasBarDistributedLoad.addRow( barDistributedLoad.StartPosition, 0, 0, 0, 0, 0, valueAtA, barDistributedLoad.EndPosition, 0, 0, 0, 0, 0, valueAtB); lusasBarDistributedLoads.Add(lusasBarDistributedLoad); lusasAssignment.setLoadset(assignedLoadcase); lusasBarDistributedLoad.assignTo(lusasLines, lusasAssignment); break; } lusasBarDistributedLoads.Add(lusasBarDistributedLoad); ids.Add(lusasBarDistributedLoad.getID()); } } } barDistributedLoad.SetAdapterId(typeof(LusasId), ids); return(lusasBarDistributedLoads); }
/***************************************************/ /**** Private helper methods ****/ /***************************************************/ private bool Analyse(IEnumerable <object> cases = null) { d_LusasData.closeAllResults(); d_LusasData.updateMesh(); string filename = d_LusasData.getDBFilename(); if (filename == "") { Engine.Base.Compute.RecordError("Model has not been saved with a filename, please SaveAs with a filename"); return(false); } d_LusasData.save(); IFLusasRunOptionsObj solverOptions = m_LusasApplication.solverOptions(); IFTabulateDataObj solverExport = m_LusasApplication.solverExport(); solverOptions.setAllDefaults(); solverExport.setFilename("%DBFolder%\\%ModelName%~Analysis 1.dat"); solverExport.setAnalysis("Analysis 1"); if (cases == null || cases.Count() == 0) { solverExport.setSolveAllLoadcases(true); } else { //Disable setSolveAllLoadcases, this overrides the setDoSolve on individual loadcases solverExport.setSolveAllLoadcases(false); List <string> names = new List <string>(); //Select provided cases foreach (object item in cases) { string name; if (item == null) { continue; } if (item is string) { name = item as string; } else if (item is ICase) { name = (item as ICase).Name; } else { Engine.Base.Compute.RecordWarning("Can not set up cases for running of type " + item.GetType().Name + ". Item " + item.ToString() + " will be ignored. Please provide case names or BHoM cases to be run"); continue; } names.Add(name); } object[] loadcases = d_LusasData.getLoadsets("loadcase", "all"); for (int i = 0; i < loadcases.Count(); i++) { IFLoadcase loadcase = (IFLoadcase)loadcases[i]; if (names.Contains(loadcase.getName())) { loadcase.setDoSolve(true); } else { loadcase.setDoSolve(false); } } } int exportError = d_LusasData.exportSolver(solverExport, solverOptions); //Did any calls to exportSolver and solve produce errors? bool exportErrors = false; bool solveErrors = false; //Any non-zero value for solveError or ExportError indicates an error int solveError; if (exportError != 0) { exportErrors = true; } else { solveError = m_LusasApplication.solve("%DBFolder%\\%ModelName%~Analysis 1.dat", solverOptions); if (solveError != 0) { solveErrors = true; } m_LusasApplication.fileOpen("%PerMachineAppDataPlatform%\\config\\AfterSolve"); m_LusasApplication.scanout("%DBFolder%\\%ModelName%~Analysis 1.out"); } m_LusasApplication.processSolveErrors(exportErrors, solveErrors); d_LusasData.openResults("%DBFolder%\\%ModelName%~Analysis 1.mys", "Analysis 1", false, 0, false, false); return(!(exportErrors & solveErrors)); }
private IFLoadingTemperature CreateTemperatureLoad(string name, double temperatureChange, object[] lusasGeometry, IFLoadcase assignedLoadcase) { IFLoadingTemperature lusasTemperatureLoad; if (d_LusasData.existsAttribute("Loading", name)) { lusasTemperatureLoad = (IFLoadingTemperature)d_LusasData.getAttributes("Loading", name); } else { lusasTemperatureLoad = d_LusasData.createLoadingTemperature(name); lusasTemperatureLoad.setValue("T0", 0); lusasTemperatureLoad.setValue("T", temperatureChange); } IFAssignment lusasAssignment = m_LusasApplication.assignment(); lusasAssignment.setLoadset(assignedLoadcase); lusasTemperatureLoad.assignTo(lusasGeometry, lusasAssignment); return(lusasTemperatureLoad); }