Example #1
0
        // LoadDistributed
        /// <summary>
        /// Returns the distributed load assignments to objects.
        /// </summary>
        /// <param name="app">The application.</param>
        /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception>
        public void GetLoadDistributed(CSiApplication app)
        {
            // TODO: Add to API project?
            app.Model.ObjectModel.FrameObject.GetLoadDistributed(Name,
                                                                 out var names,
                                                                 out var loadPatterns,
                                                                 out var forceTypes,
                                                                 out var loadDirections,
                                                                 out var startLoadValues,
                                                                 out var endLoadValues,
                                                                 out var absoluteDistanceStartFromI,
                                                                 out var absoluteDistanceEndFromI,
                                                                 out var relativeDistanceStartFromI,
                                                                 out var relativeDistanceEndFromI,
                                                                 out var coordinateSystems);

            for (int i = 0; i < names.Length; i++)
            {
                FrameLoadDistributed distributedLoad = new FrameLoadDistributed
                {
                    LoadPattern                = loadPatterns[i],
                    ForceType                  = forceTypes[i],
                    LoadDirection              = loadDirections[i],
                    StartLoadValue             = startLoadValues[i],
                    EndLoadValue               = endLoadValues[i],
                    AbsoluteDistanceStartFromI = absoluteDistanceStartFromI[i],
                    AbsoluteDistanceEndFromI   = absoluteDistanceEndFromI[i],
                    RelativeDistanceStartFromI = relativeDistanceStartFromI[i],
                    RelativeDistanceEndFromI   = relativeDistanceEndFromI[i],
                    CoordinateSystem           = coordinateSystems[i],
                };

                DistributedLoads.Add(distributedLoad);
            }
        }
        /// <summary>
        /// Sets the frame loads distributed.
        /// </summary>
        /// <param name="model">The model.</param>
        /// <param name="table">The table.</param>
        private static void setFRAME_LOADS_DISTRIBUTED(Model model, List <Dictionary <string, string> > table)
        {
            foreach (Dictionary <string, string> tableRow in table)
            {
                Frame frame = model.Structure.Frames[tableRow["Frame"]];

                RelativeAbsoluteLength distanceFromI = new RelativeAbsoluteLength(frame.Length)
                {
                    UseRelativeDistance = (tableRow["DistType"] == "RelDist")
                };
                if (distanceFromI.UseRelativeDistance)
                {
                    distanceFromI.RelativeDistanceStart = Adaptor.toDouble(tableRow["RelDistA"]);
                    distanceFromI.RelativeDistanceEnd   = Adaptor.toDouble(tableRow["RelDistB"]);
                }
                else
                {
                    distanceFromI.ActualDistanceStart = Adaptor.toDouble(tableRow["AbsDistA"]);
                    distanceFromI.ActualDistanceEnd   = Adaptor.toDouble(tableRow["AbsDistB"]);
                }

                FrameLoadDistributed load = new FrameLoadDistributed
                {
                    LoadPattern      = tableRow["LoadPat"],
                    CoordinateSystem = tableRow["CoordSys"],
                    ForceType        = Enums.EnumLibrary.ConvertStringToEnumByDescription <eLoadForceType>(tableRow["Type"]),
                    LoadDirection    = Enums.EnumLibrary.ConvertStringToEnumByDescription <eLoadDirection>(tableRow["Dir"]),
                    DistanceFromI    = distanceFromI,
                    GUID             = tableRow["GUID"],
                };
                if (tableRow.ContainsKey("FOverLA"))
                {
                    load.StartLoadValue = Adaptor.toDouble(tableRow["FOverLA"]);
                }
                if (tableRow.ContainsKey("MOverLA"))
                {
                    load.StartLoadValue = Adaptor.toDouble(tableRow["MOverLA"]);
                }
                if (tableRow.ContainsKey("FOverLB"))
                {
                    load.EndLoadValue = Adaptor.toDouble(tableRow["FOverLB"]);
                }
                if (tableRow.ContainsKey("MOverLB"))
                {
                    load.EndLoadValue = Adaptor.toDouble(tableRow["MOverLB"]);
                }

                frame.AddLoadDistributed(load);
            }
        }
Example #3
0
 /// <summary>
 /// Assigns distributed loads to frame objects.
 /// </summary>
 /// <param name="app">The application.</param>
 /// <param name="distributedLoad">The distributed load.</param>
 /// <param name="replace">True: All previous distributed loads, if any, assigned to the specified object(s), in the specified load pattern, are deleted before making the new assignment.</param>
 /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception>
 public void SetLoadDistributed(CSiApplication app,
                                FrameLoadDistributed distributedLoad,
                                bool replace = true)
 {
     // TODO: Add to API project?
     // TODO: For load, ensure that absolute distance values are always created, even if relative values are used.
     app.Model.ObjectModel.FrameObject.SetLoadDistributed(Name,
                                                          distributedLoad.LoadPattern,
                                                          distributedLoad.ForceType,
                                                          distributedLoad.LoadDirection,
                                                          distributedLoad.StartLoadValue,
                                                          distributedLoad.EndLoadValue,
                                                          distributedLoad.AbsoluteDistanceStartFromI,
                                                          distributedLoad.AbsoluteDistanceEndFromI,
                                                          distanceIsRelative: false,
                                                          coordinateSystem: distributedLoad.CoordinateSystem,
                                                          replace: replace);
 }