示例#1
0
 /// <summary>
 /// Set the Releases of a frame
 /// </summary>
 /// <param name="Frame">Frame to set up releases of</param>
 /// <param name="Release">Use the Release node</param>
 /// <returns>The frame with the new releases</returns>
 public static Frame SetReleases(Frame Frame, Release Release)
 {
     // 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}", Frame.ID.ToString());
     // Add any loads the frame already has
     newFrm.Loads = Frame.Loads;
     // Set the release in the node
     newFrm.Releases = Release;
     return newFrm;
 }
示例#2
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");
            }
        }
示例#3
0
        /// <summary>
        /// Create a Frame from a line
        /// </summary>
        /// <param name="Line">Line to create a frame</param>
        /// <param name="SectionProp">Section properties of the frame</param>
        /// <param name="Justification">Justification of the frame</param>
        /// <param name="Rotation">Angle rotation of the frame</param>
        /// <returns>Frame with all the properties set up by the inputs</returns>
        public static Frame FromLine(Line Line, SectionProp SectionProp, string Justification = "MiddleCenter", double Rotation = 0)
        {
            Frame tFrm;
            FrmID tFrmid = DynamoServices.TraceUtils.GetTraceData(TRACE_ID) as FrmID;

            if (tFrmid == null)
            {
                // trace cache log didnot return an object, create new one !
                tFrm = new Frame(Line, SectionProp, Justification, Rotation);
                // Set Label
                tFrm.Label = String.Format("dyn_{0}", tFrm.ID.ToString());
            }
            else
            {
                tFrm = TracedFrameManager.GetFramebyID(tFrmid.IntID);

                tFrm.BaseCrv = Line;
                tFrm.SecProp = SectionProp;
                tFrm.Just = Justification;
                tFrm.Angle = Rotation;
            }

            //Set the trace data on the return to be this Frame
            DynamoServices.TraceUtils.SetTraceData(TRACE_ID, new FrmID { IntID = tFrm.ID });

            return tFrm;
        }
示例#4
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;
        }
示例#5
0
 // DYNAMO DISPLAY NODES
 /// <summary>
 /// Display the Releases of a Frame
 /// </summary>
 /// <param name="frame">Frame to display the releases on (if any)</param>
 /// <param name="radius">Radius of the spheres </param>
 /// <returns>Spheres representing the Releases</returns>
 public static List<Sphere> DisplayReleases(Frame frame, double radius = 10.0)
 {
     List<Sphere> rSpheres = new List<Sphere>();
     if (frame.Releases.u1i == true || frame.Releases.u2i == true || frame.Releases.u3i == true || frame.Releases.r1i == true || frame.Releases.r2i == true || frame.Releases.r3i == true)
     {
         Sphere s = Sphere.ByCenterPointRadius(frame.BaseCrv.PointAtParameter(0.15), radius);
         rSpheres.Add(s);
     }
     if (frame.Releases.u1j == true || frame.Releases.u2j == true || frame.Releases.u3j == true || frame.Releases.r1j == true || frame.Releases.r2j == true || frame.Releases.r3j == true)
     {
         Sphere s = Sphere.ByCenterPointRadius(frame.BaseCrv.PointAtParameter(0.85), radius);
         rSpheres.Add(s);
     }
     return rSpheres;
 }
示例#6
0
 public static Dictionary<string, object> Decompose(Frame Frame)
 {
     if (Frame.Type == Structure.Type.Frame)
     {
         // Return outputs
         return new Dictionary<string, object>
         {
             {"BaseCurve", Frame.BaseCrv},
             {"SectionProp", Frame.SecProp},
             {"Justification", Frame.Just},
             {"Rotation", Frame.Angle},
             {"Loads", Frame.Loads},
             {"Releases", Frame.Releases}
         };
     }
     return null;
 }
示例#7
0
        // Set releases of a Frame
        private static void SetReleases(Frame frm, ref cSapModel mySapModel)
        {
            List<bool> ireleases = new List<bool>();
            ireleases.Add(frm.Releases.u1i); ireleases.Add(frm.Releases.u2i); ireleases.Add(frm.Releases.u3i);
            ireleases.Add(frm.Releases.r1i); ireleases.Add(frm.Releases.r2i); ireleases.Add(frm.Releases.r3i);

            List<bool> jreleases = new List<bool>();
            jreleases.Add(frm.Releases.u1j); jreleases.Add(frm.Releases.u2j); jreleases.Add(frm.Releases.u3j);
            jreleases.Add(frm.Releases.r1j); jreleases.Add(frm.Releases.r2j); jreleases.Add(frm.Releases.r3j);

            bool[] iireleases = ireleases.ToArray();
            bool[] jjreleases = jreleases.ToArray();
            string error = string.Empty;
            SAPConnection.ReleaseMapper.Set(ref mySapModel, frm.Label, iireleases, jjreleases, ref error);

            if (error != string.Empty) report.Add(error);
        }
示例#8
0
 // Set Loads to a frame
 private static void SetLoads(Frame frm, ref cSapModel mySapModel)
 {
     foreach (var load in frm.Loads)
     {
         if (load.LoadType == "PointLoad")
         {
             //Call the CreatePointLoad method
             SAPConnection.LoadMapper.CreatePointLoad(ref mySapModel, frm.Label, load.lPattern.name, load.FMType, load.Dir, load.Dist, load.Val, load.CSys, load.RelDist, true);
         }
         if (load.LoadType == "DistributedLoad")
         {
             //Call the CreateDistributedLoad method
             SAPConnection.LoadMapper.CreateDistributedLoad(ref mySapModel, frm.Label, load.lPattern.name, load.FMType, load.Dir, load.Dist, load.Dist2, load.Val, load.Val2, load.CSys, load.RelDist, true);
         }
     }
 }
示例#9
0
        //CREATE FRAME METHOD
        //Create or Update Frame
        private static void CreateorUpdateFrame(Frame f, ref cSapModel mySapModel, double SF, bool update)
        {
            string error = string.Empty;
            if (!update) // Create new
            {
                // Draw Frm Object return Label
                string dummy = string.Empty;

                //1. Create Frame
                SAPConnection.StructureMapper.CreateorUpdateFrm(ref mySapModel, f.BaseCrv.StartPoint.X * SF,
                    f.BaseCrv.StartPoint.Y * SF,
                    f.BaseCrv.StartPoint.Z * SF,
                    f.BaseCrv.EndPoint.X * SF,
                    f.BaseCrv.EndPoint.Y * SF,
                    f.BaseCrv.EndPoint.Z * SF,
                    ref dummy, false, ref error);

                // Set custom Label to Frame in dynamo & Frame! User can match by using Label & ID
                bool renamed = SAPConnection.StructureMapper.ChangeNameSAPFrm(ref mySapModel, dummy, f.Label);
                if (!renamed)
                {
                    f.Label = dummy;
                }

            }
            else // Update Coordinates
            {
                string id = f.Label;
                SAPConnection.StructureMapper.CreateorUpdateFrm(ref mySapModel, f.BaseCrv.StartPoint.X * SF,
                    f.BaseCrv.StartPoint.Y * SF,
                    f.BaseCrv.StartPoint.Z * SF,
                    f.BaseCrv.EndPoint.X * SF,
                    f.BaseCrv.EndPoint.Y * SF,
                    f.BaseCrv.EndPoint.Z * SF,
                    ref id, true, ref error);
            }
            if (error != string.Empty)
            {
                report.Add(error);
                error = string.Empty;
            }

            // 3. Get or Define Section Profile
            bool exists = SAPConnection.StructureMapper.IsSectionExistsFrm(ref mySapModel, f.SecProp.SectName, ref error);
            if (error != string.Empty)
            {
                report.Add(error);
                error = string.Empty;
            }

            if (!exists) // if it does not exist, define a new sec property
            {
                string MatProp = SAPConnection.MaterialMapper.DynamoToSap(f.SecProp.MatProp);
                //Import new section property
                SAPConnection.StructureMapper.ImportPropFrm(ref mySapModel, f.SecProp.SectName, MatProp, f.SecProp.SectCatalog, ref error);
                if (error != string.Empty)
                {
                    report.Add(error);
                    error = string.Empty;
                }
            }
            //Assign section profile toFrame
            SAPConnection.StructureMapper.SetSectionFrm(ref mySapModel, f.Label, f.SecProp.SectName, ref error);
            if (error != string.Empty)
            {
                report.Add(error);
                error = string.Empty;
            }

            // 3. Set Justification TODO: Vertical & Lateral Justification
            SAPConnection.JustificationMapper.DynamoToSAPFrm(ref mySapModel, f.Label, f.Just, ref error); // TO DO: lateral and vertical justificaton
            if (error != string.Empty)
            {
                report.Add(error);
                error = string.Empty;
            }

            // 4. Set Rotation
            SAPConnection.JustificationMapper.SetRotationFrm(ref mySapModel, f.Label, f.Angle, ref error);
            if (error != string.Empty)
            {
                report.Add(error);
                error = string.Empty;
            }
        }