Ejemplo n.º 1
0
 public void generateNodes(IRobotStructure str, Node[] nodes)
 {
     for (int i = 0; i < nodes.Length; i++)
     {
         str.Nodes.Create(nodes[i].id, nodes[i].xCoord, nodes[i].yCoord, nodes[i].zCoord);
     }
 }
Ejemplo n.º 2
0
 public void generateBars(IRobotStructure str, Bar[] bars)
 {
     for (int i = 0; i < bars.Length; i++)
     {
         str.Bars.Create(bars[i].id, bars[i].startNode.id, bars[i].endNode.id);
     }
 }
        public RobotLabels()
        {
            Structure structure = new Structure();

            str    = structure.getStructure();
            labels = str.Labels;
        }
Ejemplo n.º 4
0
        private double _windz = 0.0;    //the wind vector

        /// <summary>
        /// Create the Robot model from scratch.
        /// </summary>
        /// <param name="_nodeInfo">A List of node objects.</param>
        /// <param name="_barInfo">A List of bar objects.</param>
        public RobotModel(IRobotApplication robot, IEnumerable <AnalyticalNode> nodeInfo, IEnumerable <AnalyticalBar> barInfo, IEnumerable <AnalyticalPlate> plateInfo)
        {
            robot.Project.New(RobotOM.IRobotProjectType.I_PT_SHELL);
            _project = robot.Project;

            if (_project == null)
            {
                throw new Exception("The robot project could not be initialized.");
            }

            //create the structure and the node and bar servers
            _structure = _project.Structure;
            _nodes     = _structure.Nodes;
            _bars      = _structure.Bars;
            _objects   = _structure.Objects;

            List <int> forWindLoads      = new List <int>();
            List <int> forLiveLoads      = new List <int>();
            List <int> forBuildingLoads  = new List <int>();
            List <int> forDeadLoadsBars  = new List <int>();
            List <int> forDeadLoadsSlabs = new List <int>();

            double windLoad     = 0.0;
            double liveLoad     = 0.0;
            double buildingLoad = 0.0;
            double fatManLoad   = 300 * 4.45;           //300lbs. -> Newton

            IRobotSimpleCase ll;
            IRobotSimpleCase dl;
            IRobotSimpleCase bl;
            IRobotSimpleCase wl;

            CreateLoadCases(out ll, out dl, out wl, out bl);

            CreateLoads(ll, dl, wl, bl);

            CreateBarEndRelease(_barInfo);

            CreateNodes();

            CreateBars(forDeadLoadsBars);

            #region plates

            CreatePlates(liveLoad, forLiveLoads, windLoad, forWindLoads, buildingLoad, forBuildingLoads, forDeadLoadsSlabs, ll, wl, bl, fatManLoad, dl, forDeadLoadsBars);

            #endregion
        }
Ejemplo n.º 5
0
        public Structure(int frames, double spam, double heigth, double offset)
        {
            //Parsing the main parameters
            this.numberOfFrames = frames;
            this.frameSpam      = spam;
            this.frameHeigth    = heigth;
            this.frameOffset    = offset;

            //Start application
            robApp = RobotController.getRobot();

            //Create a project
            RobotProjectController.createProject(robApp);

            //Create a structure
            str = robApp.Project.Structure;
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Starting Robot application...");
            //Cria um novo objeto da aplicação Robot
            IRobotApplication robApp = new RobotApplicationClass();

            //Se a aplicaçao não estiver visivel, torna o robot visivel para permitir iteracao
            if (robApp.Visible == 0)
            {
                robApp.Interactive = 1;
                robApp.Visible     = 1;
            }

            Console.WriteLine("Creating concrete project...");
            //Cria o projeto da viga de concreto
            robApp.Project.New(IRobotProjectType.I_PT_SHELL);

            Console.WriteLine("Executing project settings...");
            //Configuracao das preferencias
            RobotProjectPreferences projectPrefs = robApp.Project.Preferences;

            //Configuracoes do codigo de verificacao da estrutura de concreto
            projectPrefs.SetActiveCode(IRobotCodeType.I_CT_RC_THEORETICAL_REINF, "BAEL 91");

            //Configuracao das preferencias de malha
            RobotMeshParams meshParams = projectPrefs.MeshParams;

            meshParams.SurfaceParams.Method.Method          = IRobotMeshMethodType.I_MMT_DELAUNAY;
            meshParams.SurfaceParams.Generation.Type        = IRobotMeshGenerationType.I_MGT_ELEMENT_SIZE;
            meshParams.SurfaceParams.Generation.ElementSize = 0.5;
            meshParams.SurfaceParams.Delaunay.Type          = IRobotMeshDelaunayType.I_MDT_DELAUNAY;

            //Geração da estrutura
            Console.WriteLine("Generating structure");
            IRobotStructure str = robApp.Project.Structure;

            Console.WriteLine("Generating nodes...");
            str.Nodes.Create(1, 0, 0, 0);
            str.Nodes.Create(2, 3, 0, 0);
            str.Nodes.Create(3, 3, 3, 0);
            str.Nodes.Create(4, 0, 3, 0);
            str.Nodes.Create(5, 0, 0, 4);
            str.Nodes.Create(6, 3, 0, 4);
            str.Nodes.Create(7, 3, 3, 4);
            str.Nodes.Create(8, 0, 3, 4);

            str.Bars.Create(1, 1, 5);
            str.Bars.Create(2, 2, 6);
            str.Bars.Create(3, 3, 7);
            str.Bars.Create(4, 4, 8);
            str.Bars.Create(5, 5, 6);
            str.Bars.Create(6, 7, 8);

            Console.WriteLine("Generating labels...");
            RobotLabelServer labels = str.Labels;

            string columnSectionName = "Rect. Column 30*30";

            IRobotLabel label = labels.Create(IRobotLabelType.I_LT_BAR_SECTION, columnSectionName);

            RobotBarSectionData section = (RobotBarSectionData)label.Data;

            section.ShapeType = IRobotBarSectionShapeType.I_BSST_CONCR_COL_R;

            RobotBarSectionConcreteData concrete = (RobotBarSectionConcreteData)section.Concrete;

            concrete.SetValue(IRobotBarSectionConcreteDataValue.I_BSCDV_COL_B, 0.3);
            concrete.SetValue(IRobotBarSectionConcreteDataValue.I_BSCDV_COL_H, 0.3);

            section.CalcNonstdGeometry();
            labels.Store(label);

            Console.WriteLine("Defining sections...");
            RobotSelection selectionBars = str.Selections.Get(IRobotObjectType.I_OT_BAR);

            selectionBars.FromText("1 2 3 4");
            str.Bars.SetLabel(selectionBars, IRobotLabelType.I_LT_BAR_SECTION, columnSectionName);

            RobotSectionDatabaseList steelSections = projectPrefs.SectionsActive;

            if (steelSections.Add("RCAT") == 1)
            {
                Console.WriteLine("Warning! Steel section base RCAT not found...");
            }

            selectionBars.FromText("5 6");
            label = labels.Create(IRobotLabelType.I_LT_BAR_SECTION, "HEA 340");
            str.Labels.Store(label);
            str.Bars.SetLabel(selectionBars, IRobotLabelType.I_LT_BAR_SECTION, "HEA 340");

            Console.WriteLine("Defining materials...");

            string materialName = "Concrete 30";

            label = labels.Create(IRobotLabelType.I_LT_MATERIAL, materialName);

            RobotMaterialData material = (RobotMaterialData)label.Data;

            material.Type     = IRobotMaterialType.I_MT_CONCRETE;
            material.E        = 3E+09;
            material.NU       = 1 / 6;
            material.RO       = 25000;
            material.Kirchoff = material.E / (2 * (1 + material.NU));

            Console.WriteLine("Generating slab...");
            RobotPointsArray points = (RobotPointsArray)robApp.CmpntFactory.Create(IRobotComponentType.I_CT_POINTS_ARRAY);

            points.SetSize(5);
            points.Set(1, 0, 0, 4);
            points.Set(2, 3, 0, 4);
            points.Set(3, 3, 3, 4);
            points.Set(4, 0, 3, 4);
            points.Set(5, 0, 0, 4);

            string slabSectionName = "Slab 30";

            label = labels.Create(IRobotLabelType.I_LT_PANEL_THICKNESS, slabSectionName);

            RobotThicknessData thickness = (RobotThicknessData)label.Data;

            thickness.MaterialName  = materialName;
            thickness.ThicknessType = IRobotThicknessType.I_TT_HOMOGENEOUS;

            RobotThicknessHomoData thicknessData = (RobotThicknessHomoData)thickness.Data;

            thicknessData.ThickConst = 0.3;
            labels.Store(label);

            RobotObjObject slab;
            int            objNumber = str.Objects.FreeNumber;

            str.Objects.CreateContour(objNumber, points);
            slab = (RobotObjObject)str.Objects.Get(objNumber);
            slab.Main.Attribs.Meshed = 1;
            slab.SetLabel(IRobotLabelType.I_LT_PANEL_THICKNESS, slabSectionName);
            slab.Initialize();

            Console.WriteLine("Adding hole in the slab...");

            points.Set(1, 1.1, 1.1, 4);
            points.Set(2, 2.5, 1.1, 4);

            RobotObjObject hole;



            Console.ReadLine();
        }
Ejemplo n.º 7
0
        private static void CalcReinforcement(RobotApplication robApp, int objNumber, RobotLabelServer labels, RobotObjObject slab, IRobotStructure str)
        {
            IRobotLabel label;
            var         concrCalcEngine = robApp.Project.ConcrReinfEngine;
            var         concrSlabRequiredReinfEngine = concrCalcEngine.SlabRequiredReinf;
            var         slabRnfParams = concrSlabRequiredReinfEngine.Params;

            slabRnfParams.Method = IRobotReinforceCalcMethods.I_RCM_WOOD_ARMER;
            slabRnfParams.GloballyAvgDesginForces = false;
            slabRnfParams.ForcesReduction         = false;
            slabRnfParams.DisplayErrors           = false;
            slabRnfParams.CasesULS.FromText("1 2 3 4 5 6 7 8");
            var slabs = slabRnfParams.Panels;

            slabs.FromText(System.Convert.ToString(objNumber));
            var slabReinforcementName = "Slab X";

            label = labels.Create(IRobotLabelType.I_LT_PANEL_REINFORCEMENT, slabReinforcementName);
            labels.Store(label);
            slab.SetLabel(IRobotLabelType.I_LT_PANEL_REINFORCEMENT, slabReinforcementName);
            slab.Update();

            Console.WriteLine(!concrSlabRequiredReinfEngine.Calculate() ? "Calculation Failed!" : "Done!");
            //getting results My and Yz for beam (bar 5) with live load (case 2)
            var txt = "Bar 5, Live at 0.5 length:" + "\n\r" +
                      " My = " + str.Results.Bars.Forces.Value(5, 2, 0.5).MY / 1000 + " [kN*m]" + "\n\r" +
                      " Qz = " + -str.Results.Bars.Deflections.Value(5, 2, 0.5).UZ * 1000 + " [mm]" + "\n\r" +
                      " Fz1 = " + str.Results.Bars.Forces.Value(5, 2, 0).FZ / 1000 + " [kN]" + "\n\r" +
                      " Fz2 = " + str.Results.Bars.Forces.Value(5, 2, 1).FZ / 1000 + " [kN]" + "\n\r";

            //getting results Fx and Fy for column (bar 4) with wind load (case 3)
            txt += "Bar 4, Wind:" + "\n\r" +
                   " Fx = " + str.Results.Bars.Forces.Value(4, 3, 1).FX / 1000 + " [kN]" + "\n\r" +
                   " Fy = " + str.Results.Bars.Forces.Value(4, 3, 1).FY / 1000 + " [kN]" + "\n\r";
            //getting results Fx, Fy, Fz, Mx, My, Mz for foot (node 1) with self-weight (case 1)
            txt += "Node 1, Self-Weight:" + "\n\r" +
                   " Fx = " + str.Results.Nodes.Reactions.Value(1, 1).FX / 1000 + " [kN]" + "\n\r" +
                   " Fy = " + str.Results.Nodes.Reactions.Value(1, 1).FY / 1000 + " [kN]" + "\n\r" +
                   " Fz = " + str.Results.Nodes.Reactions.Value(1, 1).FZ / 1000 + " [kN]" + "\n\r" +
                   " Mx = " + str.Results.Nodes.Reactions.Value(1, 1).MX / 1000 + " [kN]" + "\n\r" +
                   " My = " + str.Results.Nodes.Reactions.Value(1, 1).MY / 1000 + " [kN]" + "\n\r" +
                   " Mz = " + str.Results.Nodes.Reactions.Value(1, 1).MZ / 1000 + " [kN]" + "\n\r";
            //getting results Ax+, Ax-, Ay+, Ay- for slab
            var selectionFe = str.Selections.Get(IRobotObjectType.I_OT_FINITE_ELEMENT);

            selectionFe.FromText(slab.FiniteElems);
            var    objFEs = (RobotLabelCollection)str.FiniteElems.GetMany(selectionFe);
            double a;

            a = 0;
            double axP = 0;
            double axM = 0;
            double ayP = 0;
            double ayM = 0;
            var    finiteElementNodes = new List <RobotFiniteElement>();

            for (var n = 1; n <= objFEs.Count; n++)
            {
                var fe = (RobotFiniteElement)objFEs.Get(n);
                finiteElementNodes.Add(fe);
                a = str.Results.FiniteElems.Reinforcement(slab.Number, fe.Number).AX_BOTTOM;
                if (a > axM)
                {
                    axM = a;
                }
                a = str.Results.FiniteElems.Reinforcement(slab.Number, fe.Number).AX_TOP;
                if (a > axP)
                {
                    axP = a;
                }

                a = str.Results.FiniteElems.Reinforcement(slab.Number, fe.Number).AY_BOTTOM;
                if (a > ayM)
                {
                    ayM = a;
                }
                a = str.Results.FiniteElems.Reinforcement(slab.Number, fe.Number).AY_TOP;
                if (a > ayP)
                {
                    ayP = a;
                }
            }

            //getting results Fx, Fy, Fz, Mx, My, Mz for foot (node 1) with self-weight (case 1)
            txt += "Slab 1, Reinforcemet extreme values:" + "\n\r" + " Ax+ = " + axP * 10000 + " [cm2]" + "\n\r" + " Ax- = " +
                   axM * 10000 + " [cm2]" + "\n\r" + " Ay+ = " + ayP * 10000 + " [cm2]" + "\n\r" + " Ay- = " + ayM * 10000 +
                   " [cm2]" + "\n\r";

            foreach (var fe in finiteElementNodes)
            {
                var nodes = fe.Nodes;
                Console.WriteLine(
                    $"{fe.Number} - {Enumerable.Range(0, nodes.Count).Aggregate("", (x, y) => $"{x} {nodes.Get(y)}")}");
            }


            Console.WriteLine(txt);
        }
Ejemplo n.º 8
0
        private static void FromTutorial()
        {
            var robApp = new RobotApplication();

            if (robApp.Visible == 0)
            {
                robApp.Interactive = 1;
                robApp.Visible     = 1;
            }
            robApp.Project.New(IRobotProjectType.I_PT_SHELL);
            var projectPrefs = robApp.Project.Preferences;

            projectPrefs.SetActiveCode(IRobotCodeType.I_CT_RC_THEORETICAL_REINF, "BAEL 91");
            var meshParams = projectPrefs.MeshParams;

            meshParams.SurfaceParams.Method.Method          = IRobotMeshMethodType.I_MMT_DELAUNAY;
            meshParams.SurfaceParams.Generation.Type        = IRobotMeshGenerationType.I_MGT_ELEMENT_SIZE;
            meshParams.SurfaceParams.Generation.ElementSize = 0.5;
            meshParams.SurfaceParams.Delaunay.Type          = IRobotMeshDelaunayType.I_MDT_DELAUNAY;

            IRobotStructure str = robApp.Project.Structure;

            str.Nodes.Create(1, 0, 0, 0);
            str.Nodes.Create(2, 3, 0, 0);
            str.Nodes.Create(3, 3, 3, 0);
            str.Nodes.Create(4, 0, 3, 0);
            str.Nodes.Create(5, 0, 0, 4);

            str.Nodes.Create(6, 3, 0, 4);
            str.Nodes.Create(7, 3, 3, 4);
            str.Nodes.Create(8, 0, 3, 4);

            str.Bars.Create(1, 1, 5);
            str.Bars.Create(2, 2, 6);
            str.Bars.Create(3, 3, 7);
            str.Bars.Create(4, 4, 8);
            str.Bars.Create(5, 5, 6);
            str.Bars.Create(6, 7, 8);

            var labels            = str.Labels;
            var columnSectionName = "Rect. Column 30*30";

            var label   = labels.Create(IRobotLabelType.I_LT_BAR_SECTION, columnSectionName);
            var section = (RobotBarSectionData)label.Data;

            section.ShapeType = IRobotBarSectionShapeType.I_BSST_CONCR_COL_R;

            var concrete = (RobotBarSectionConcreteData)section.Concrete;

            concrete.SetValue(IRobotBarSectionConcreteDataValue.I_BSCDV_COL_B, 0.3);
            concrete.SetValue(IRobotBarSectionConcreteDataValue.I_BSCDV_COL_H, 0.3);
            section.CalcNonstdGeometry();
            labels.Store(label);
            var selectionBars = str.Selections.Get(IRobotObjectType.I_OT_BAR);

            selectionBars.FromText("1 2 3 4");
            str.Bars.SetLabel(selectionBars, IRobotLabelType.I_LT_BAR_SECTION, columnSectionName);
            var steelSections = projectPrefs.SectionsActive;

            if (steelSections.Add("RCAT") == 1)
            {
                Console.WriteLine("Steel section base RCAT not found...");
            }
            selectionBars.FromText("5 6");
            label = labels.Create(IRobotLabelType.I_LT_BAR_SECTION, "HEA 340");
            str.Labels.Store(label);
            str.Bars.SetLabel(selectionBars, IRobotLabelType.I_LT_BAR_SECTION, "HEA 340");
            var materialName = "Concrete 30";

            label = labels.Create(IRobotLabelType.I_LT_MATERIAL, materialName);
            var material = (RobotMaterialData)label.Data;

            material.Type = IRobotMaterialType.I_MT_CONCRETE;
            material.E    = 30000000000;   // Young
            material.NU   = 1 / (double)6; // Poisson

            material.RO       = 25000;     // Unit weight
            material.Kirchoff = material.E / (2 * (1 + material.NU));
            str.Labels.Store(label);
            var points = (RobotPointsArray)robApp.CmpntFactory.Create(IRobotComponentType.I_CT_POINTS_ARRAY);

            points.SetSize(5);
            points.Set(1, 0, 0, 4);
            points.Set(2, 3, 0, 4);
            points.Set(3, 3, 3, 4);
            points.Set(4, 0, 3, 4);
            points.Set(5, 0, 0, 4);
            var slabSectionName = "Slab 30";

            label = labels.Create(IRobotLabelType.I_LT_PANEL_THICKNESS, slabSectionName);
            var thickness = (RobotThicknessData)label.Data;

            thickness.MaterialName  = materialName;
            thickness.ThicknessType = IRobotThicknessType.I_TT_HOMOGENEOUS;
            var thicknessData = (RobotThicknessHomoData)thickness.Data;

            thicknessData.ThickConst = 0.3;
            labels.Store(label);
            var objNumber = str.Objects.FreeNumber;

            str.Objects.CreateContour(objNumber, points);
            var slab = (RobotObjObject)str.Objects.Get(objNumber);

            slab.Main.Attribs.Meshed = 1;
            slab.SetLabel(IRobotLabelType.I_LT_PANEL_THICKNESS, slabSectionName);
            slab.Initialize();
            points.Set(1, 1.1, 1.1, 4);
            points.Set(2, 2.5, 1.1, 4);
            points.Set(3, 2.5, 2.5, 4);
            points.Set(4, 1.1, 2.5, 4);
            points.Set(5, 1.1, 1.1, 4);
            var holeNumber = str.Objects.FreeNumber;

            str.Objects.CreateContour(holeNumber, points);
            var hole = (RobotObjObject)str.Objects.Get(holeNumber);

            hole.Main.Attribs.Meshed = 0;
            hole.Initialize();
            var footName = "Foot";

            label = labels.Create(IRobotLabelType.I_LT_SUPPORT, footName);
            var footData = (RobotNodeSupportData)label.Data;

            footData.UX = 1;
            footData.UY = 1;
            footData.UZ = 1;
            footData.KZ = 80000000;
            footData.RX = 1;

            footData.RY = 1;
            footData.RZ = 1;
            labels.Store(label);
            var selectionNodes = str.Selections.Get(IRobotObjectType.I_OT_NODE);

            selectionNodes.FromText("1 2 3 4");
            str.Nodes.SetLabel(selectionNodes, IRobotLabelType.I_LT_SUPPORT, footName);
            //self weight on entire structure
            var caseSw = str.Cases.CreateSimple(1, "SW", IRobotCaseNature.I_CN_PERMANENT, IRobotCaseAnalizeType.I_CAT_STATIC_LINEAR);

            caseSw.Records.New(IRobotLoadRecordType.I_LRT_DEAD);
            var loadRecord = (RobotLoadRecord)caseSw.Records.Get(1);

            loadRecord.SetValue(System.Convert.ToInt16(IRobotDeadRecordValues.I_DRV_Z), -1);
            loadRecord.SetValue(System.Convert.ToInt16(IRobotDeadRecordValues.I_DRV_ENTIRE_STRUCTURE), 0);
            //contour live load on the slab
            var caseLive = str.Cases.CreateSimple(2, "Live", IRobotCaseNature.I_CN_EXPLOATATION, IRobotCaseAnalizeType.I_CAT_STATIC_LINEAR);
            var uniform  = caseLive.Records.New(IRobotLoadRecordType.I_LRT_UNIFORM);

            loadRecord = (RobotLoadRecord)caseLive.Records.Get(uniform);
            loadRecord.SetValue(System.Convert.ToInt16(IRobotUniformRecordValues.I_URV_PX), 0);
            loadRecord.SetValue(System.Convert.ToInt16(IRobotUniformRecordValues.I_URV_PY), 0);
            loadRecord.SetValue(System.Convert.ToInt16(IRobotUniformRecordValues.I_URV_PZ), -10000);
            //apply created load to the slab
            loadRecord.Objects.FromText(System.Convert.ToString(objNumber));
            //linear wind load on the beam
            var caseWind = str.Cases.CreateSimple(3, "Wind", IRobotCaseNature.I_CN_WIND, IRobotCaseAnalizeType.I_CAT_STATIC_LINEAR);

            uniform    = caseWind.Records.New(IRobotLoadRecordType.I_LRT_BAR_UNIFORM);
            loadRecord = (RobotLoadRecord)caseWind.Records.Get(uniform);
            loadRecord.SetValue(System.Convert.ToInt16(IRobotUniformRecordValues.I_URV_PX), 0);
            loadRecord.SetValue(System.Convert.ToInt16(IRobotUniformRecordValues.I_URV_PY), 1000);

            loadRecord.SetValue(System.Convert.ToInt16(IRobotUniformRecordValues.I_URV_PZ), 0);
            //apply created load to the beam
            loadRecord.Objects.FromText("5");
            var calcEngine = robApp.Project.CalcEngine;

            calcEngine.GenerationParams.GenerateNodes_BarsAndFiniteElems = true;
            calcEngine.UseStatusWindow = true;

            if (calcEngine.Calculate() == 1)
            {
                Console.WriteLine("Calculation Failed!");
            }
            else
            {
                Console.WriteLine("Done!");
            }

            calcEngine = null;

            //CalcReinforcement(robApp, objNumber, labels, slab, str);
        }
Ejemplo n.º 9
0
        private double _windz = 0.0; //the wind vector

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Create the Robot model from scratch.
        /// </summary>
        /// <param name="_nodeInfo">A List of node objects.</param>
        /// <param name="_barInfo">A List of bar objects.</param>
        public RobotModel(IRobotApplication robot, IEnumerable<AnalyticalNode> nodeInfo, IEnumerable<AnalyticalBar> barInfo, IEnumerable<AnalyticalPlate> plateInfo)
        {
            robot.Project.New(RobotOM.IRobotProjectType.I_PT_SHELL);
            _project = robot.Project;

            if (_project == null)
                throw new Exception("The robot project could not be initialized.");

            //create the structure and the node and bar servers
            _structure = _project.Structure;
            _nodes = _structure.Nodes;
            _bars = _structure.Bars;
            _objects = _structure.Objects;

            List<int> forWindLoads = new List<int>();
            List<int> forLiveLoads = new List<int>();
            List<int> forBuildingLoads = new List<int>();
            List<int> forDeadLoadsBars = new List<int>();
            List<int> forDeadLoadsSlabs = new List<int>();

            double windLoad	= 0.0;
            double liveLoad = 0.0;
            double buildingLoad = 0.0;
            double fatManLoad = 300 * 4.45;	//300lbs. -> Newton

            IRobotSimpleCase ll;
            IRobotSimpleCase dl;
            IRobotSimpleCase bl;
            IRobotSimpleCase wl;
            CreateLoadCases(out ll, out dl, out wl, out bl);

            CreateLoads(ll,dl, wl, bl);

            CreateBarEndRelease(_barInfo);

            CreateNodes();

            CreateBars(forDeadLoadsBars);

            #region plates

            CreatePlates(liveLoad, forLiveLoads, windLoad, forWindLoads, buildingLoad, forBuildingLoads, forDeadLoadsSlabs, ll, wl, bl, fatManLoad, dl, forDeadLoadsBars);

            #endregion
        }
Ejemplo n.º 10
0
        public void DoCommand(int cmd_id)
        {
            IRobotStructure structure = robot_app.Project.Structure;

            // Get bars and nodes
            IRobotCollection bars  = structure.Bars.GetAll();
            IRobotCollection nodes = structure.Nodes.GetAll();

            // Create 3D points at nodes
            var points = new Dictionary <int, Point3D>();

            for (int i = 1; i <= nodes.Count; i++)
            {
                var node = (IRobotNode)nodes.Get(i);
                points[i] = new Point3D(node.X, node.Y, node.Z);
            }

            // Create 3D vectors for each bar and index of bars connected to a node
            var vectors    = new Dictionary <int, Vector3D>();
            var vect_by_pt = new DefaultDict <int, List <Vector3D> >();

            for (int i = 1; i <= bars.Count; i++)
            {
                var bar      = (IRobotBar)bars.Get(i);
                var start_pt = points[bar.StartNode];
                var end_pt   = points[bar.EndNode];
                vectors[i] = end_pt - start_pt;
                vect_by_pt[bar.StartNode].Add(vectors[i]);
                vect_by_pt[bar.EndNode].Add(vectors[i]);
            }
            ;

            foreach (KeyValuePair <int, Vector3D> vector in vectors)
            {
                // `u` is the vector corresponding to the bar
                Vector3D     u      = vector.Value;
                UnitVector3D u_norm = u.Normalize();
                int          start  = bars.Get(vector.Key).StartNode;
                // TODO: How about the other end?

                // Find the most orthogonal vector `v`
                Vector3D most_orth_v = u;
                double   cur_min     = 1;
                foreach (Vector3D x in vect_by_pt[start])
                {
                    UnitVector3D x_norm   = x.Normalize();
                    double       dot_prod = Math.Abs(u_norm.DotProduct(x_norm));
                    if (dot_prod < cur_min)
                    {
                        most_orth_v = x;
                        cur_min     = dot_prod;
                    }
                }

                if (cur_min > 0.95)
                {
                    continue;
                }

                var v      = most_orth_v;
                var v_norm = v.Normalize();

                // Vector `a` is vector a orthogonal to `u` in (u,v) plane
                Vector3D     a      = v - u_norm.DotProduct(v) * u;
                UnitVector3D a_norm = a.Normalize();

                // Vector `c` is orthogonal to `u` in the global (X,Y) plane
                UnitVector3D c = u_norm.CrossProduct(UnitVector3D.ZAxis);
                // Vector `d` is orthogonal to `c` and `u`
                UnitVector3D d = c.CrossProduct(u_norm);

                // Calculate the angles of `a` with `d` and `c`
                Angle theta1 = a.AngleTo(d);
                Angle theta2 = a.AngleTo(c);

                // Calculate gamma from `theta1` and `theta2`
                Angle  gamma    = (theta2.Degrees < 90) ? theta1 : -theta1;
                double gamma_up = (gamma.Degrees < 0) ? gamma.Degrees + 90 : gamma.Degrees - 90;

                // Set `Gamma` attribute of bar
                IRobotBar bar = bars.Get(vector.Key);
                bar.Gamma = gamma_up;
            }

            // Redraw all views
            robot_app.Project.ViewMngr.Refresh();
        }