Example #1
0
        internal static void StructuralModelFromSapFile(ref cSapModel SapModel, ref StructuralModel model, string SapModelUnits)
        {
            model.StructuralElements = new List<Element>();
            model.ModelDefinitions = new List<Definition>();

            List<LoadPattern> TempLPatterns = new List<LoadPattern>();

            string error = string.Empty;
            if (SapModel != null)
            {

                // 1.a GET LOAD PATTERNS

                string[] LoadPatternNames = null;
                string[] LoadPatternTypes = null;
                double[] LoadPatternMultipliers = null;

                StructureMapper.GetLoadPatterns(ref SapModel, ref LoadPatternNames, ref LoadPatternTypes, ref LoadPatternMultipliers);
                if (LoadPatternNames != null)
                {
                    foreach (string lpname in LoadPatternNames)
                    {
                        int pos = Array.IndexOf(LoadPatternNames, lpname);
                        LoadPattern lp = new LoadPattern(lpname, LoadPatternTypes[pos], LoadPatternMultipliers[pos]);
                        model.ModelDefinitions.Add(lp);
                        TempLPatterns.Add(lp);
                    }
                }

                // 1.b GET LOAD CASES

                string[] LoadCasesNames = null;
                string[] LoadCasesTypes = null;
                double[] LoadCasesMultipliers = null;

                //With this method we only get the name and the type of each load case
                StructureMapper.GetLoadCases(ref SapModel, ref LoadCasesNames, ref LoadCasesMultipliers, ref LoadCasesTypes);
                if (LoadCasesNames != null)
                {
                    foreach (string lcname in LoadCasesNames)
                    {
                        int pos = Array.IndexOf(LoadCasesNames, lcname);

                        //create a new load
                        LoadCase lc = new LoadCase();
                        lc.name = lcname;
                        lc.type = LoadCasesTypes[pos];

                        model.ModelDefinitions.Add(lc);

                    }
                }

                //1.c GET LOAD COMBOS

                string[] LoadCombosNames = null;
                string[][] LoadCombosTypes = null;
                string[][] LoadCombosCases = null;
                string[][] LoadCombosDefinitions = null;
                double[][] LoadCombosMultipliers = null;

                StructureMapper.GetLoadCombos(ref SapModel, ref LoadCombosNames, ref LoadCombosTypes, ref LoadCombosCases, ref LoadCombosMultipliers, ref LoadCombosDefinitions);

                if (LoadCombosNames != null)
                {

                    foreach (string lcname in LoadCombosNames)
                    {
                        int pos = Array.IndexOf(LoadCombosNames, lcname);

                        List<Definition> LoadDefinitions = new List<Definition>();

                        foreach (string comboType in LoadCombosTypes[pos])
                        {
                            int pos2 = Array.IndexOf(LoadCombosTypes[pos], comboType);
                            Definition def = new Definition();
                            if (comboType == "LoadCase")
                            {
                                //find the existing Load Case
                                foreach (Definition d in model.ModelDefinitions)
                                {
                                    if (d.Type == Definitions.Type.LoadCase)
                                    {
                                        if (((LoadCase)d).name == LoadCombosDefinitions[pos][pos2])
                                        {
                                            def = d;
                                        }
                                    }
                                }
                            }
                            else
                            {
                                def.Type = Definitions.Type.LoadCombo;
                                ((LoadCombo)def).name = comboType;
                            }

                            LoadDefinitions.Add(def);
                        }

                        //create a new load combo
                        LoadCombo loadcombo = new LoadCombo(lcname, LoadCombosTypes[pos][0], LoadDefinitions, LoadCombosMultipliers[pos].ToList());

                        model.ModelDefinitions.Add(loadcombo);

                    }
                }

                // 2. GET DYNAMO FRAMES ( get Loads and Releases that are assigned to that frame)
                //2.a GET LOADS that are Assigned to Frames

                Dictionary<int, string> DictFrm_PointLoads = new Dictionary<int, string>();
                Dictionary<int, string> DictFrm_DistLoads = new Dictionary<int, string>();

                //Get Point Loads
                string[] framesWithPointLoads = null;
                string[] PlPattern = null;
                int Pnumber = 0;
                int[] PmyType = null;
                string[] PCsys = null;
                int[] Pdir = null;
                double[] PRelDist = null;
                double[] PDist = null;
                double[] PVal = null;

                LoadMapper.GetPointLoads(ref SapModel, ref framesWithPointLoads, ref Pnumber, ref PlPattern, ref PmyType, ref PCsys, ref Pdir, ref PRelDist, ref PDist, ref PVal);
                if (framesWithPointLoads != null)
                {
                    for (int i = 0; i < framesWithPointLoads.Count(); i++)
                    {
                        DictFrm_PointLoads.Add(i, framesWithPointLoads[i]);
                    }
                }

                // Get Distributed Loads
                string[] framesWithDistributedLoads = null;
                string[] DlPattern = null;
                int Dnumber = 0;
                int[] DmyType = null;
                string[] DCsys = null;
                int[] Ddir = null;
                double[] DRD1 = null;
                double[] DRD2 = null;
                double[] DDist1 = null;
                double[] DDist2 = null;
                double[] DVal1 = null;
                double[] DVal2 = null;

                LoadMapper.GetDistributedLoads(ref SapModel, ref framesWithDistributedLoads, ref Dnumber, ref DlPattern, ref DmyType, ref DCsys, ref Ddir, ref DRD1, ref DRD2, ref DDist1, ref DDist2, ref DVal1, ref DVal2);
                if (framesWithDistributedLoads != null)
                {
                    for (int i = 0; i < framesWithDistributedLoads.Count(); i++)
                    {
                        DictFrm_DistLoads.Add(i, framesWithDistributedLoads[i]);
                    }
                }

                //2.b Get Frames

                // Calculate Length Scale Factor
                //Double SF = Utilities.UnitConversion("m", SapModelUnits); // Dynamo API Lenght Unit is 'meter'
                Double SF = 1;

                List<string> FrmIds = new List<string>();
                StructureMapper.GetSAPFrameList(ref SapModel,ref FrmIds);

                for (int i = 0; i < FrmIds.Count; i++)
                {
                    Point s = null;
                    Point e = null;
                    string matProp = "A992Fy50"; // default value
                    string secName = "W12X14"; // default value
                    string secCatalog = "AISC14"; // default value
                    string Just = "MiddleCenter"; // default value
                    double Rot = 0; // default value

                    StructureMapper.GetFrm(ref SapModel, FrmIds[i], ref s, ref e, ref matProp, ref secName, ref Just, ref Rot, ref secCatalog, SF);
                    SectionProp secProp = new SectionProp(secName, matProp, secCatalog);
                    Frame d_frm = new Frame(s, e, secProp, Just, Rot);
                    d_frm.Label = FrmIds[i];
                    model.StructuralElements.Add(d_frm);

                    //LOADS
                    // Frame might have multiple loads assigned to it...
                    d_frm.Loads = new List<Load>();

                    //Check if the frame has distributed loads
                    var outindexes = from obj in DictFrm_DistLoads
                                     where obj.Value == d_frm.Label
                                     select obj.Key;

                    foreach(int index in outindexes)
                    {
                       LoadPattern Dlp = null;
                       foreach (LoadPattern loadp in TempLPatterns)
                        {
                            if (loadp.name == DlPattern[index])
                            {
                                Dlp = loadp;
                                break;
                            }
                        }
                        if (Dlp != null)
                        {
                            // using relDist as true, and using the relative distance values DRD1 and DRD2
                            bool relDist = true;
                            Load l = new Load(Dlp, DmyType[index], Ddir[index], DRD1[index], DRD2[index], DVal1[index], DVal2[index], DCsys[index], relDist);
                            l.LoadType = "DistributedLoad";
                            d_frm.Loads.Add(l);
                        }
                    }

                    //Check if the frame has Point Loads
                    var outindexesO = from obj in DictFrm_PointLoads
                                      where obj.Value == d_frm.Label
                                      select obj.Key;

                    foreach (int index in outindexesO)
                    {
                        LoadPattern Plp = null;
                        foreach (LoadPattern loadp in TempLPatterns)
                        {
                            if (loadp.name == PlPattern[index])
                            {
                                Plp = loadp;
                                break;
                            }
                        }

                        if (Plp != null)
                        {
                            bool relativedist = true;
                            Load l = new Load(Plp, PmyType[index], Pdir[index], PRelDist[index], PVal[index], PCsys[index], relativedist);
                            l.LoadType = "PointLoad";
                            d_frm.Loads.Add(l);
                        }
                    }

                    //RELEASES
                    bool[] ii = new bool[6];
                    bool[] jj = new bool[6];
                    ReleaseMapper.Get(ref SapModel, FrmIds[i], ref ii, ref jj);

                    // Populate if return releases
                    if (ii.Contains(true) || jj.Contains(true))
                    {
                        d_frm.Releases = Release.Set(ii[0], jj[0]
                                                    , ii[1], jj[1]
                                                    , ii[2], jj[2]
                                                    , ii[3], jj[3]
                                                    , ii[4], jj[4]
                                                    , ii[5], jj[5]);
                    }
                }

                // 2.b Get Shells from SAP Model
                List<string> AreaIds = new List<string>();
                SAPConnection.StructureMapper.GetSAPAreaList(ref SapModel, ref AreaIds);

                for (int i = 0; i < AreaIds.Count; i++)
                {
                    Surface S = null;

                    string propName = string.Empty;
                    SAPConnection.StructureMapper.GetShell(ref SapModel, AreaIds[i], ref S, SF, ref propName);

                    int ShellType= 1;
                    bool DOF = true;
                    string MatProp = string.Empty;
                    double MatAngle = 0;
                    double Thickness = 0;
                    double Bending = 0;
                    SAPConnection.StructureMapper.GetShellProp(ref SapModel, propName, ref ShellType, ref DOF, ref MatProp, ref MatAngle, ref Thickness, ref Bending);
                    ShellProp sP = new ShellProp(propName, ShellType, DOF, MatProp, MatAngle, Thickness * SF, Bending);

                    Shell d_Shell = new Shell(S, sP);
                    d_Shell.Label = AreaIds[i];
                    model.StructuralElements.Add(d_Shell);
                }

                // 3. GET RESTRAINTS
                int CountRes = RestraintMapper.Count(ref SapModel);
                if (CountRes > 0)
                {

                    List<string> PtIds = new List<string>();
                    RestraintMapper.GetSupportedPts(ref SapModel, ref PtIds);

                    // Populate Dynamo Restraints
                    foreach (var PtId in PtIds)
                    {
                        Point Pti = null;
                        bool[] restraints = new bool[6];

                        RestraintMapper.Get(ref SapModel, PtId, ref Pti, ref restraints, SF);

                        Joint myj = new Joint(Pti);
                        myj.Label = PtId;

                        // Populate on Joint Restraints
                        Restraint support = Restraint.Define(restraints[0], restraints[1], restraints[2], restraints[3], restraints[4], restraints[5]);

                        myj.JointRestraint = support;

                        model.StructuralElements.Add(myj);
                    }
                }

            }
            else
            {
                throw new Exception("Make sure SAP Model is open!");
            }

            // Get Groups
            List<String> SapGroups = new List<string>();
            SAPConnection.GroupMapper.GetSAPGroupList(ref SapModel, ref SapGroups);

            int counter = 0;
            foreach (var g in SapGroups)
            {
                Group myG = new Group();
                myG.Name = g;
                myG.GroupElements = new List<Element>();

                // get assignments
                int[] types = null;
                string[] Labels = null;
                SAPConnection.GroupMapper.GetGroupAssignments(ref SapModel, g, ref types, ref Labels);

                if (Labels!=null && Labels.Count() > 0)
                {
                    for (int i = 0; i < Labels.Length; i++)
                    {
                        if (types[i] == 1) // Joint
                        {
                            try
                            {
                                var gel = (from el in model.StructuralElements
                                           where el.Label == Labels[i] && el.Type == Structure.Type.Joint
                                           select el).First();
                                if (gel != null)
                                {
                                    myG.GroupElements.Add(gel);
                                }

                            }
                            catch (Exception) { }

                        }
                        else if (types[i] == 2) // frame
                        {
                            try
                            {
                                var gel = (from el in model.StructuralElements
                                           where el.Type == Structure.Type.Frame && el.Label == Labels[i]
                                           select el).First();
                                if (gel != null)
                                {
                                    myG.GroupElements.Add(gel);
                                }

                            }
                            catch (Exception) { }
                        }
                        else if (types[i] == 3) // cable
                        {
                            //TODO: After cable object defined
                        }
                        else if (types[i] == 5) // shell
                        {
                            var gel = (from el in model.StructuralElements
                                       where el.Type == Structure.Type.Shell && el.Label == Labels[i]
                                       select el).First();
                            if (gel != null)
                            {
                                myG.GroupElements.Add(gel);
                            }
                        }

                    }
                }
                else
                {
                   counter++;
                }

                //Add to Model definitions
                model.ModelDefinitions.Add(myG);

            }
            if (counter == SapGroups.Count)
            {
                //throw new Exception("The group(s) have no members assigned");
            }
        }
Example #2
0
        /// <summary>
        /// Set a Load on a Frame
        /// </summary>
        /// <param name="Frame">Frame to set up loads on</param>
        /// <param name="Load">Load to apply to the frame</param>
        /// <param name="replaceExisting">Set Boolean to True to replace existing Loads on the Frame</param>
        /// <returns>The frame with the new loads(and the previous ones, if it applies)</returns>
        public static Frame SetLoad(Frame Frame, Load Load, bool replaceExisting = false)
        {
            // Create a new Frame using the properties of the input frame
            Frame newFrm = Frame.FromLine(Frame.BaseCurve, Frame.SecProp, Frame.Just, Frame.Angle);
            // Set Label
            newFrm.Label = String.Format("dyn_{0}", newFrm.ID.ToString());
            // Add any releases the frame already has
            newFrm.Releases = Frame.Releases;

            //Set the load in the node
            List<Load> frameLoads = new List<Load>();
            if (Frame.Loads != null)
            {
                if (replaceExisting) // if true, delete the list and add the new Load
                {
                    Frame.Loads.Clear();
                }
                else
                {
                    foreach (Load l in Frame.Loads)
                    {
                        frameLoads.Add(l);
                    }
                }
            }
            frameLoads.Add(Load);
            newFrm.Loads = frameLoads;

            return newFrm;
        }
Example #3
0
        public static Dictionary<string, object> Decompose(Load Load)
        {
            if (Load != null)
            {
                string d2 = ""; // if it is a Point Load this should return empty
                string v2 = "";// if it is a Point Load this should return empty

                if (Load.LoadType == "DistributedLoad")
                {
                    //if it is a Distributed Load
                    d2 = Load.Dist2.ToString();
                    v2 = Load.Val2.ToString();
                }

                string forceOrMoment = "";
                if (Load.FMType == 1) forceOrMoment = "Force";
                else if (Load.FMType == 2) forceOrMoment = "Moment";

                string axisDir = "";
                if (Load.CSys == "GLOBAL" || Load.CSys == "global" || Load.CSys == "Global")
                {
                    if (Load.Dir == 4) axisDir = "Global X direction";
                    else if (Load.Dir == 5) axisDir = "Global Y direction";
                    else if (Load.Dir == 6) axisDir = "Global Z direction";
                    else if (Load.Dir == 7) axisDir = "Projected X direction";
                    else if (Load.Dir == 8) axisDir = "Projected Y direction";
                    else if (Load.Dir == 9) axisDir = "Projected Z direction";
                    else if (Load.Dir == 10) axisDir = "Gravity direction";
                    else if (Load.Dir == 11) axisDir = "Projected gravity direction";
                }

                else // for local coordinate systems
                {
                    if (Load.Dir == 1) axisDir = "Local 1 axis";
                    else if (Load.Dir == 2) axisDir = "Local 2 axis";
                    else if (Load.Dir == 3) axisDir = "Local 3 axis";
                }

                // Return outputs
                return new Dictionary<string, object>
            {
                {"Load Type", Load.LoadType},
                {"Load Pattern", Load.lPattern.name},
                {"Force/Moment Type", forceOrMoment},
                {"Direction", axisDir},
                {"Distance", Load.Dist},
                {"Distance 2", d2},
                {"Value", Load.Val},
                {"Value 2", v2},
                {"Coordinate System", Load.CSys},
                {"Relative Distance", Load.RelDist}
            };
            }
            else
            {
                return new Dictionary<string, object>
            {
                {"Load Type", null},
                {"Load Pattern", null},
                {"Force/Moment Type", null},
                {"Direction", null},
                {"Distance", null},
                {"Distance 2", null},
                {"Value",null},
                {"Value 2", null},
                {"Coordinate System", null},
                {"Relative Distance",null}
            };
            }
        }
Example #4
0
        /// <summary>
        /// This function assigns loads to frame objects.
        /// Parameters description below as presented in the SAP CSi OAPI Documentation
        /// </summary>
        /// <param name="LoadPattern">The name of a defined load pattern.</param>
        /// <param name="LoadType">Force or moment load. Use the Load Type dropdown</param>
        /// <param name="Direction">This is an integer between 1 and 11, indicating the direction of the load.
        /// 1 = Local 1 axis (only applies when CSys is Local)
        /// 2 = Local 2 axis (only applies when CSys is Local)
        /// 3 = Local 3 axis (only applies when CSys is Local)
        /// 4 = X direction (does not apply when CSys is Local)
        /// 5 = Y direction (does not apply when CSys is Local)
        /// 6 = Z direction (does not apply when CSys is Local)
        /// 7 = Projected X direction (does not apply when CSys is Local)
        /// 8 = Projected Y direction (does not apply when CSys is Local)
        /// 9 = Projected Z direction (does not apply when CSys is Local)
        /// 10 = Gravity direction (only applies when CSys is Global)
        /// 11 = Projected Gravity direction (only applies when CSys is Global)
        /// The positive gravity direction (see Dir = 10 and 11) is in the negative Global Z direction.</param>
        /// <param name="Distance">This is the distance from the I-End of the frame object to the load location. 
        /// This may be a relative distance (0 less or equal to Dist less or equal to 1) or an actual distance, 
        /// depending on the value of the RelDist item. [L] when RelDist is False</param>
        /// <param name="Value">This is the value of the point load. [F] when MyType is 1 and [FL] when MyType is 2</param>
        /// <param name="CoordSystem">This is Local or the name of a defined coordinate system. 
        /// It is the coordinate system in which the loads are specified.</param>
        /// <param name="RelativeDistance">If this item is True, the specified Dist item is a relative distance, 
        /// otherwise it is an actual distance.</param>
        /// <param name="Replace">If this item is True, all previous loads, if any, assigned to the specified frame object(s), 
        /// in the specified load pattern, are deleted before making the new assignment.</param>
        /// <returns>Load at a point along a Frame</returns>
        //DYNAMO CREATE NODES
        public static Load PointLoad(LoadPattern LoadPattern, string LoadType, int Direction, double Distance, double Value, string CoordSystem = "Global", bool RelativeDistance = true, bool Replace = true)
        {
            int ltype = 1;
            if (LoadType == "Moment") ltype = 2;

            CheckCoordSysAndDir(Direction, CoordSystem);
            Load l = new Load(LoadPattern, ltype, Direction, Distance, Value, CoordSystem, RelativeDistance);
            l.LoadType = "PointLoad";
            return l;
        }
Example #5
0
        public static Dictionary <string, object> Decompose(Load Load)
        {
            if (Load != null)
            {
                string d2 = ""; // if it is a Point Load this should return empty
                string v2 = ""; // if it is a Point Load this should return empty

                if (Load.LoadType == "DistributedLoad")
                {
                    //if it is a Distributed Load
                    d2 = Load.Dist2.ToString();
                    v2 = Load.Val2.ToString();
                }

                string forceOrMoment = "";
                if (Load.FMType == 1)
                {
                    forceOrMoment = "Force";
                }
                else if (Load.FMType == 2)
                {
                    forceOrMoment = "Moment";
                }


                string axisDir = "";
                if (Load.CSys == "GLOBAL" || Load.CSys == "global" || Load.CSys == "Global")
                {
                    if (Load.Dir == 4)
                    {
                        axisDir = "Global X direction";
                    }
                    else if (Load.Dir == 5)
                    {
                        axisDir = "Global Y direction";
                    }
                    else if (Load.Dir == 6)
                    {
                        axisDir = "Global Z direction";
                    }
                    else if (Load.Dir == 7)
                    {
                        axisDir = "Projected X direction";
                    }
                    else if (Load.Dir == 8)
                    {
                        axisDir = "Projected Y direction";
                    }
                    else if (Load.Dir == 9)
                    {
                        axisDir = "Projected Z direction";
                    }
                    else if (Load.Dir == 10)
                    {
                        axisDir = "Gravity direction";
                    }
                    else if (Load.Dir == 11)
                    {
                        axisDir = "Projected gravity direction";
                    }
                }


                else // for local coordinate systems
                {
                    if (Load.Dir == 1)
                    {
                        axisDir = "Local 1 axis";
                    }
                    else if (Load.Dir == 2)
                    {
                        axisDir = "Local 2 axis";
                    }
                    else if (Load.Dir == 3)
                    {
                        axisDir = "Local 3 axis";
                    }
                }


                // Return outputs
                return(new Dictionary <string, object>
                {
                    { "Load Type", Load.LoadType },
                    { "Load Pattern", Load.lPattern.name },
                    { "Force/Moment Type", forceOrMoment },
                    { "Direction", axisDir },
                    { "Distance", Load.Dist },
                    { "Distance 2", d2 },
                    { "Value", Load.Val },
                    { "Value 2", v2 },
                    { "Coordinate System", Load.CSys },
                    { "Relative Distance", Load.RelDist }
                });
            }
            else
            {
                return(new Dictionary <string, object>
                {
                    { "Load Type", null },
                    { "Load Pattern", null },
                    { "Force/Moment Type", null },
                    { "Direction", null },
                    { "Distance", null },
                    { "Distance 2", null },
                    { "Value", null },
                    { "Value 2", null },
                    { "Coordinate System", null },
                    { "Relative Distance", null }
                });
            }
        }