/// <summary>
        /// Reports the command history
        /// </summary>
        public bool CommandTrackingReport(ref string message)
        {
            if (0 == m_dictionary.Count)
            {
                return(false);
            }

            var keys = m_dictionary.Keys;

            Array.Sort(keys);

            var sb = new StringBuilder();

            foreach (var k in keys)
            {
                sb.AppendFormat("{0} = {1}\n", k, m_dictionary.GetInteger(k));
            }

            message = sb.ToString();

            return(true);
        }
Ejemplo n.º 2
0
        protected override void ReadDocument(RhinoDoc doc, BinaryArchiveReader archive, FileReadOptions options)
        {
            Beams.Clear();
            CurrentBeam = null;

            if (unitfactors.ContainsKey(RhinoDoc.ActiveDoc.ModelUnitSystem))
            {
                Unitfactor = unitfactors[RhinoDoc.ActiveDoc.ModelUnitSystem];
            }
            else
            {
                MessageBox.Show("Cross section design tool does not support the chosen" +
                                "unit system. Unit system will be changed to millimeters.");
                RhinoDoc.ActiveDoc.ModelUnitSystem = UnitSystem.Millimeters;
                Unitfactor = unitfactors[RhinoDoc.ActiveDoc.ModelUnitSystem];
            }



            try
            {
                ArchivableDictionary dict = archive.ReadDictionary();

                int i     = 1;
                int count = 0;
                if (dict["BeamCount"] != null)
                {
                    count = (int)dict["BeamCount"];
                }

                dict.Set("CountUserData", CountableUserData.getCounter());
                while (i < count + 1)
                {
                    Beam   bTemp;
                    string beamName = (string)dict["BeamName" + i];

                    if ((string)dict["BeamType" + i] == "Column")
                    {
                        bTemp = new Column(beamName, dict.GetDouble("Gammas" + i),
                                           dict.GetDouble("Gammac" + i),
                                           dict.GetDouble("Gammar" + i),
                                           dict.GetDouble("Acc" + i))
                        {
                            Length = (double)dict["ColLength" + i],
                            Ky     = (double)dict["ky" + i],
                            Kz     = (double)dict["kz" + i],
                        };
                        ((Column)bTemp).ColumnCalcSettings.ColumnCalMethod[ColumnCalculationMethod.NominalCurvature1] =
                            dict.GetBool("ColumnCalculationSettings1" + i);
                        ((Column)bTemp).ColumnCalcSettings.ColumnCalMethod[ColumnCalculationMethod.NominalCurvature2] =
                            dict.GetBool("ColumnCalculationSettings2" + i);
                        ((Column)bTemp).ColumnCalcSettings.ColumnCalMethod[ColumnCalculationMethod.NominalStiffness1] =
                            dict.GetBool("ColumnCalculationSettings3" + i);
                        ((Column)bTemp).ColumnCalcSettings.ColumnCalMethod[ColumnCalculationMethod.NominalStiffness2] =
                            dict.GetBool("ColumnCalculationSettings4" + i);
                    }
                    else
                    {
                        bTemp = new Beam(beamName, dict.GetDouble("Gammas" + i),
                                         dict.GetDouble("Gammac" + i),
                                         dict.GetDouble("Gammar" + i),
                                         dict.GetDouble("Acc" + i))
                        {
                        };
                    }

                    bTemp.ClimateCond = new ClimateCondition(
                        (int)dict["Rh" + i],
                        (int)dict["T0" + i],
                        (int)dict["T" + i],
                        bTemp);

                    string       crossSecName = (string)dict["CrossSecName" + i];
                    CrossSection cTemp;
                    if ((string)dict["CrossSectionType" + i] == "Basic")
                    {
                        cTemp =
                            new CrossSection(crossSecName, bTemp)
                        {
                        };
                    }

                    else if (dict.GetString("CrossSectionType" + i) == "Rect")
                    {
                        cTemp =
                            new RectangleCrossSection(crossSecName, bTemp)
                        {
                            NoReinfH       = (int)dict["NoReinfH" + i],
                            NoReinfW       = (int)dict["NoReinfW" + i],
                            ConcreteCover  = (int)dict["ConcreteCover" + i],
                            ConcreteWidth  = dict.GetInteger("ConcreteWidth" + i),
                            ConcreteHeight = dict.GetInteger("ConcreteHeight" + i),
                            HasSteelShell  = dict.GetBool("HasSteelShell" + i),
                            SteelThickness = dict.GetDouble("SteelThickness" + i),
                            MainD          = dict.GetInteger("MainDiameter" + i),
                            StirrupD       = dict.GetInteger("StirrupDiameter" + i),
                            SteelMaterial  = new SteelMaterial(dict.GetString("SteelMaterialName" + i) ?? "S355", SteelType.StructuralSteel, bTemp),
                            ReinfMaterial  = new SteelMaterial(dict.GetString("ReinforcementMaterialName" + i ?? "B500B"), SteelType.Reinforcement, bTemp),
                            Rotation       = dict.GetInteger("Rotation" + i),
                        };
                    }
                    else
                    {
                        cTemp =
                            new CircleCrossSection(crossSecName, bTemp)
                        {
                            NoReinf          = (int)dict["NoReinf"],
                            ConcreteCover    = (int)dict["ConcreteCover" + i],
                            ConcreteDiameter = dict.GetInteger("ConcreteDiameter" + i),
                            HasSteelShell    = dict.GetBool("HasSteelShell" + i),
                            SteelThickness   = dict.GetDouble("SteelThickness" + i),
                            MainD            = dict.GetInteger("MainDiameter" + i),
                            StirrupD         = dict.GetInteger("StirrupDiameter" + i),
                            SteelMaterial    = new SteelMaterial(dict.GetString("SteelMaterialName" + i) ?? "S355", SteelType.StructuralSteel, bTemp),
                            ReinfMaterial    = new SteelMaterial(dict.GetString("ReinforcementMaterialName" + i) ?? "B500B", SteelType.Reinforcement, bTemp),
                        };
                    }


                    //Sets a link between reinforcements and the beam
                    List <int> reinforcements = ((int[])dict["reinf" + i]).ToList();

                    List <Reinforcement> temp = GetReinforcements(reinforcements);
                    temp.ForEach(o => o.Material.Bm = bTemp);



                    //Sets a link between geometry larges and the beam
                    List <int> geometryLarges = ((int[])dict["geomLarges" + i]).ToList();

                    List <GeometryLarge> gls = GetGeometryLarges(geometryLarges);
                    gls.ForEach(o => o.Material.Bm = bTemp);


                    cTemp.ConcreteMaterial = new ConcreteMaterial((string)dict["ConcreteStrenghtClass" + i], bTemp);
                    bTemp.CrossSec         = cTemp;
                    geometryLarges.ForEach(id => cTemp.GeometryLargeIds.Add(id));
                    reinforcements.ForEach(id => cTemp.ReinforementIds.Add(id));
                    bTemp.Id = dict.GetInteger("BeamId" + i);
                    Beams.Add(bTemp);



                    //Set loadCases
                    int lc_n = dict.GetInteger("NumberOfLoadCases" + i);
                    int k    = 1;
                    while (k <= lc_n)
                    {
                        string name           = dict.GetString("LoadCaseName" + i + "s" + k);
                        int    limitStatenumb = dict.GetInteger("LimitState" + i + "s" + k);

                        LimitState ls;
                        switch (limitStatenumb)
                        {
                        case 0:
                            ls = LimitState.Ultimate; break;

                        case 1:
                            ls = LimitState.Service_CH; break;

                        case 2:
                            ls = LimitState.Service_FR; break;

                        case 3:
                            ls = LimitState.Service_QP; break;

                        default:
                            ls = LimitState.Ultimate; break;
                        }
                        ;

                        if (dict.GetString("LoadCaseType" + i + "s" + k) == "ColLoadCase")
                        {
                            ColLoadCase clc = new ColLoadCase(
                                dict.GetDouble("N_Ed" + i + "s" + k),
                                dict.GetDouble("M_EzTop" + i + "s" + k),
                                dict.GetDouble("M_EzBottom" + i + "s" + k),
                                dict.GetDouble("M_EyTop" + i + "s" + k),
                                dict.GetDouble("M_EyBottom" + i + "s" + k),
                                (Column)bTemp,
                                dict.GetDouble("Ratio" + i + "s" + k),
                                name,
                                dict.GetDouble("CCurve" + i + "s" + k),
                                ls);
                        }
                        else if (dict.GetString("LoadCaseType" + i + "s" + k) == "SimpleLoadCase")
                        {
                            SimpleLoadCase slc = new SimpleLoadCase(
                                dict.GetDouble("N_Ed" + i + "s" + k),
                                dict.GetDouble("M_Edz" + i + "s" + k),
                                dict.GetDouble("M_Edy" + i + "s" + k),
                                bTemp,
                                name,
                                ls);
                            bTemp.LoadCases.Add(slc);
                        }
                        k++;
                    }


                    i++;
                }
                Countable.SetCounter(i - 2);
                if (Beams.Count != 0)
                {
                    int currentID = (int)dict["currentBeamId"];
                    if (currentID != -1)
                    {
                        CurrentBeam = Beams.FirstOrDefault(beam => beam.Id == currentID);
                    }
                }

                CountableUserData.setCounter((int)dict["CountableUserData"]);

                if (MainForm != null)
                {
                    MainForm.ChangeToStartView();
                }

                //If there is previous display results, clear them
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, ex.Source, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                base.ReadDocument(doc, archive, options);
            }
        }