コード例 #1
0
ファイル: DistributedLoad.cs プロジェクト: BHoM/Lusas_Toolkit
        /***************************************************/

        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);
        }
コード例 #2
0
        /***************************************************/
        /**** 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);
        }
コード例 #3
0
        /***************************************************/
        /**** 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);
        }
コード例 #4
0
ファイル: Surface.cs プロジェクト: BHoM/Lusas_Toolkit
        /***************************************************/
        /**** 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);
        }
コード例 #5
0
        /***************************************************/
        /**** 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);
        }
コード例 #6
0
        /***************************************************/
        /**** Private Methods                           ****/
        /***************************************************/

        private static IEnumerable <IGrouping <string, IFAssignment> > GetLoadAssignments(IFLoading lusasForce)
        {
            object[]            assignmentObjects = lusasForce.getAssignments();
            List <IFAssignment> assignments       = new List <IFAssignment>();

            for (int j = 0; j < assignmentObjects.Count(); j++)
            {
                IFAssignment assignment = (IFAssignment)assignmentObjects[j];
                assignments.Add(assignment);
            }

            IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases =
                assignments.GroupBy(m => m.getAssignmentLoadset().getName());

            return(groupedByLoadcases);
        }
コード例 #7
0
        /***************************************************/
        /**** Private Methods                           ****/
        /***************************************************/

        private static List <string> GetAttributeAssignments(IFGeometry lusasGeometry, string attributeType)
        {
            object[] lusasAssignments = lusasGeometry.getAssignments(attributeType);

            List <string> attributeNames = new List <string>();

            int n = lusasAssignments.Count();

            for (int i = 0; i < n; i++)
            {
                IFAssignment lusasAssignment = lusasGeometry.getAssignments(attributeType)[i];
                IFAttribute  lusasAttribute  = lusasAssignment.getAttribute();
                string       attributeName   = GetName(lusasAttribute);
                attributeNames.Add(attributeName);
            }

            return(attributeNames);
        }
コード例 #8
0
        /***************************************************/
        /**** Private Methods                           ****/
        /***************************************************/

        private static void AssignmentWarning(IFAssignment lusasAssignment)
        {
            if (lusasAssignment.getDatabaseObject() is IFPoint)
            {
                Engine.Base.Compute.RecordWarning(
                    lusasAssignment.GetType().ToString() + " does not support assignment to points, these have not been pulled");
            }
            else if (lusasAssignment.getDatabaseObject() is IFLine)
            {
                Engine.Base.Compute.RecordWarning(
                    lusasAssignment.GetType().ToString() + "  does not support assignment to lines, these have not been pulled");
            }
            else if (lusasAssignment.getDatabaseObject() is IFSurface)
            {
                Engine.Base.Compute.RecordWarning(
                    lusasAssignment.GetType().ToString() + " does not support assignment to surfaces, these have not been pulled");
            }
        }
コード例 #9
0
        /***************************************************/
        /**** Private Methods                           ****/
        /***************************************************/

        private void DeletePointAssignments(object[] lusasAttributes)
        {
            for (int i = 0; i < lusasAttributes.Count(); i++)
            {
                IFAttribute lusasAttribute   = (IFAttribute)lusasAttributes[i];
                object[]    lusasAssignments = lusasAttribute.getAssignments();
                for (int j = 0; j < lusasAssignments.Count(); j++)
                {
                    IFAssignment lusasAssignment = (IFAssignment)lusasAssignments[j];
                    IFGeometry   lusasGeometry   = (IFGeometry)lusasAssignment.getDatabaseObject();
                    if (lusasGeometry is IFPoint)
                    {
                        Engine.Base.Compute.RecordWarning(lusasAttribute.getName() + " has been deleted because it was assigned to a point");
                        d_LusasData.Delete(lusasAttribute);
                        break;
                    }
                }
            }
        }
コード例 #10
0
ファイル: DistributedLoad.cs プロジェクト: BHoM/Lusas_Toolkit
        /***************************************************/

        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);
        }
コード例 #11
0
        /***************************************************/
        /**** Private Methods                           ****/
        /***************************************************/

        public static Tuple <bool, double, BarRelease, BarFEAType> GetMeshProperties(IFLine lusasLine)
        {
            bool       meshAssigned = true;
            double     betaAngle    = 0;
            BarRelease barRelease   = null;
            BarFEAType barType      = BarFEAType.Flexural;

            object[] meshAssignments = lusasLine.getAssignments("Mesh");

            if (meshAssignments.Length > 0)
            {
                foreach (object assignment in meshAssignments)
                {
                    IFAssignment lusasAssignment = (IFAssignment)assignment;
                    IFAttribute  lusasMesh       = lusasAssignment.getAttribute();
                    IFMeshLine   lusasLineMesh   = (IFMeshLine)lusasMesh;
                    betaAngle = lusasAssignment.getBetaAngle();

                    barRelease = GetBarRelease(lusasLineMesh);

                    object[] barMeshName = lusasLineMesh.getElementNames();

                    foreach (object type in barMeshName)
                    {
                        barType = GetFEAType(type);
                    }
                }
            }
            else
            {
                meshAssigned = false;
            }

            Tuple <bool, double, BarRelease, BarFEAType> lineMeshProperties =
                new Tuple <bool, double, BarRelease, BarFEAType>(meshAssigned, betaAngle, barRelease, barType);

            return(lineMeshProperties);
        }
コード例 #12
0
        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);
        }
コード例 #13
0
ファイル: BarPointLoad.cs プロジェクト: BHoM/Lusas_Toolkit
        /***************************************************/
        /**** 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);
        }
コード例 #14
0
        /***************************************************/
        /**** Private Methods                           ****/
        /***************************************************/

        private IFLine CreateLine(Bar bar)
        {
            if (!CheckPropertyError(bar, b => b.StartNode, true) || !CheckPropertyError(bar, b => b.EndNode, true) ||
                !CheckPropertyError(bar, b => b.StartNode.Position, true) || !CheckPropertyError(bar, b => b.EndNode.Position, true))
            {
                return(null);
            }

            if (
                bar.FEAType == BarFEAType.CompressionOnly ||
                bar.FEAType == BarFEAType.TensionOnly)
            {
                Engine.Base.Compute.RecordError("Lusas does not support " + bar.FEAType.ToString() + " Bars");
                return(null);
            }

            string startNodeId = GetAdapterId <string>(bar.StartNode);
            string endNodeId   = GetAdapterId <string>(bar.EndNode);

            if (string.IsNullOrEmpty(startNodeId) || string.IsNullOrEmpty(endNodeId))
            {
                Engine.Base.Compute.RecordError("Could not find the ids for at least one end node for at least one Bar. Bar not created.");
                return(null);
            }

            IFPoint startPoint = d_LusasData.getPointByNumber(bar.StartNode.AdapterId <int>(typeof(LusasId)));
            IFPoint endPoint   = d_LusasData.getPointByNumber(bar.EndNode.AdapterId <int>(typeof(LusasId)));
            IFLine  lusasLine  = d_LusasData.createLineByPoints(startPoint, endPoint);

            int adapterIdName = lusasLine.getID();

            bar.SetAdapterId(typeof(LusasId), adapterIdName);

            if (bar.Tags.Count != 0)
            {
                AssignObjectSet(lusasLine, bar.Tags);
            }

            if (CheckPropertyWarning(bar, b => b.SectionProperty) && !Engine.Adapters.Lusas.Query.InvalidSectionProperty(bar.SectionProperty))
            {
                if (!Engine.Adapters.Lusas.Query.InvalidSectionProfile(bar.SectionProperty))
                {
                    //Needed in case the SectionProfile is null and was not created
                    if (d_LusasData.existsAttribute("Line Geometric", bar.SectionProperty.AdapterId <int>(typeof(LusasId))))
                    {
                        IFAttribute lusasGeometricLine = d_LusasData.getAttribute("Line Geometric", bar.SectionProperty.AdapterId <int>(typeof(LusasId)));
                        lusasGeometricLine.assignTo(lusasLine);
                    }

                    if (CheckPropertyWarning(bar, b => b.SectionProperty.Material))
                    {
                        if (bar.SectionProperty.Material is IOrthotropic)
                        {
                            Engine.Base.Compute.RecordWarning($"Orthotropic Material {bar.SectionProperty.Material.DescriptionOrName()} cannot be assigned to Bar {bar.AdapterId<int>(typeof(LusasId))}, " +
                                                              $"orthotropic materials can only be applied to 2D and 3D elements in Lusas.");
                        }
                        else if (bar.SectionProperty.Material is IIsotropic)
                        {
                            if (d_LusasData.existsAttribute("Material", bar.SectionProperty.Material.AdapterId <int>(typeof(LusasId))))
                            {
                                IFAttribute lusasMaterial = d_LusasData.getAttribute("Material", bar.SectionProperty.Material.AdapterId <int>(typeof(LusasId)));
                                lusasMaterial.assignTo(lusasLine);
                            }
                        }
                    }
                }
            }

            if (bar.Support != null)
            {
                IFAttribute lusasSupport = d_LusasData.getAttribute("Support", System.Convert.ToInt32(bar.Support.AdapterId <int>(typeof(LusasId))));
                lusasSupport.assignTo(lusasLine);
                IFLocalCoord barLocalAxis = CreateLocalCoordinate(lusasLine);
                barLocalAxis.assignTo(lusasLine);
            }

            if (bar.Fragments.Contains(typeof(MeshSettings1D)))
            {
                IFAssignment meshAssignment = m_LusasApplication.newAssignment();
                meshAssignment.setAllDefaults();
                if (bar.OrientationAngle != 0 && bar.FEAType == BarFEAType.Axial)
                {
                    Engine.Base.Compute.RecordWarning(
                        "Orientation angle not supported in Lusas for " + bar.FEAType +
                        " element types, this information will be lost when pushed to Lusas");
                }

                meshAssignment.setBetaAngle(bar.OrientationAngle);

                MeshSettings1D meshSettings1D = bar.FindFragment <MeshSettings1D>();
                IFMeshAttr     mesh           = d_LusasData.getMesh(
                    meshSettings1D.Name + "\\" + bar.FEAType.ToString() + "|" + CreateReleaseString(bar.Release));
                mesh.assignTo(lusasLine, meshAssignment);
            }

            if (bar.Offset != null)
            {
                Engine.Base.Compute.RecordWarning("Offsets are currently unsupported.");
            }

            return(lusasLine);
        }
コード例 #15
0
        /***************************************************/
        /**** 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);
        }