コード例 #1
0
ファイル: PropertiesEditor.cs プロジェクト: up2038292/dwsim6
        void Initialize()
        {
            var su  = SimObject.GetFlowsheet().FlowsheetOptions.SelectedUnitSystem;
            var nf  = SimObject.GetFlowsheet().FlowsheetOptions.NumberFormat;
            var nff = SimObject.GetFlowsheet().FlowsheetOptions.FractionNumberFormat;

            s.CreateAndAddLabelRow(container, "Dynamic Properties Editor");

            s.CreateAndAddDescriptionRow(container, "Property values are updated/stored as they are changed/edited. There's no need to press ENTER to commit the changes.");

            switch (SimObject.GraphicObject.ObjectType)
            {
            case ObjectType.MaterialStream:
                container.CreateAndAddDropDownRow("Dynamic Specification",
                                                  SimObject.DynamicsSpec.GetEnumNames(), (int)SimObject.DynamicsSpec, (dd, e) => {
                    SimObject.DynamicsSpec = dd.SelectedIndex.ToEnum <Interfaces.Enums.Dynamics.DynamicsSpecType>();
                    SimObject.GetFlowsheet().UpdateInterface();
                });
                break;
            }

            var col1 = (IDictionary <string, object>)SimObject.ExtraProperties;
            var col2 = (IDictionary <string, object>)SimObject.ExtraPropertiesDescriptions;
            var col3 = (IDictionary <string, object>)SimObject.ExtraPropertiesUnitTypes;

            foreach (var p in col1)
            {
                if (col2.ContainsKey(p.Key) && col3.ContainsKey(p.Key))
                {
                    string unitsstring = "";
                    try
                    {
                        var utype = col3[p.Key];
                        Interfaces.Enums.UnitOfMeasure eval = (Interfaces.Enums.UnitOfMeasure)System.Enum.ToObject(typeof(Interfaces.Enums.UnitOfMeasure), utype);
                        unitsstring = su.GetCurrentUnits(eval);
                    }
                    catch { }
                    container.CreateAndAddTextBoxRow("G", unitsstring != "" ? p.Key + " (" + unitsstring + ")" : p.Key,
                                                     p.Value.ToString().ToDoubleFromCurrent(),
                                                     (tb, e) => {
                        try
                        {
                            col1[p.Key]  = tb.Text.ToDoubleFromCurrent();
                            tb.TextColor = Colors.Blue;
                        }
                        catch
                        {
                            tb.TextColor = Colors.Red;
                        }
                    });
                    container.CreateAndAddDescriptionRow(col2[p.Key].ToString());
                    container.CreateAndAddEmptySpace();
                }
            }

            s.CreateAndAddEmptySpace(container);
            s.CreateAndAddEmptySpace(container);
        }
コード例 #2
0
ファイル: PipeSection.cs プロジェクト: jmptrader/dwsim6
        void Initialize()
        {
            var su = flowsheet.FlowsheetOptions.SelectedUnitSystem;
            var nf = flowsheet.FlowsheetOptions.NumberFormat;

            if (section.TipoSegmento == "Tubulaosimples")
            {
                section.TipoSegmento = "Straight Tube Section";
            }

            var lblseg = container.CreateAndAddTwoLabelsRow("Segment", section.Indice.ToString());

            container.CreateAndAddDropDownRow("Type", sectypes, Array.IndexOf(sectypes.ToArray(), section.TipoSegmento), (sender, e) => section.TipoSegmento = sectypes[sender.SelectedIndex]);
            var cbm = container.CreateAndAddDropDownRow("Material", materials, Array.IndexOf(materials.ToArray(), section.Material), (sender, e) => section.Material = materials[sender.SelectedIndex]);
            var tbr = container.CreateAndAddTextBoxRow("G8", "Rugosity " + " (" + su.distance + ") *", cv.ConvertFromSI(su.distance, section.PipeWallRugosity), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                                                 {
                                                                                                                                                                                     section.PipeWallRugosity = cv.ConvertToSI(su.distance, sender.Text.ParseExpressionToDouble());
                                                                                                                                                                                 }
                                                       });
            var tbtc = container.CreateAndAddStringEditorRow("Thermal Conductivity " + " (" + su.thermalConductivity + ") *", section.PipeWallThermalConductivityExpression, (sender, e) => { section.PipeWallThermalConductivityExpression = sender.Text.ToString(); });

            container.CreateAndAddTextBoxRow("N0", "Increments", section.Incrementos, (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                       {
                                                                                                           section.Incrementos = int.Parse(sender.Text.ToString());
                                                                                                       }
                                             });
            container.CreateAndAddTextBoxRow("N0", "Quantity", section.Quantidade, (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                    {
                                                                                                        section.Quantidade = int.Parse(sender.Text.ToString());
                                                                                                    }
                                             });
            container.CreateAndAddTextBoxRow(nf, "Length" + " (" + su.distance + ")", cv.ConvertFromSI(su.distance, section.Comprimento), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                           {
                                                                                                                                                               section.Comprimento = cv.ConvertToSI(su.distance, sender.Text.ParseExpressionToDouble());
                                                                                                                                                           }
                                             });
            container.CreateAndAddTextBoxRow(nf, "Elevation" + " (" + su.distance + ")", cv.ConvertFromSI(su.distance, section.Elevacao), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                           {
                                                                                                                                                               section.Elevacao = cv.ConvertToSI(su.distance, sender.Text.ParseExpressionToDouble());
                                                                                                                                                           }
                                             });
            container.CreateAndAddTextBoxRow(nf, "External Diameter" + " (" + su.diameter + ")", cv.Convert("in", su.diameter, section.DE), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                             {
                                                                                                                                                                 section.DE = cv.Convert(su.diameter, "in", sender.Text.ParseExpressionToDouble());
                                                                                                                                                             }
                                             });
            container.CreateAndAddTextBoxRow(nf, "Internal Diameter" + " (" + su.diameter + ")", cv.Convert("in", su.diameter, section.DI), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                             {
                                                                                                                                                                 section.DI = cv.Convert(su.diameter, "in", sender.Text.ParseExpressionToDouble());
                                                                                                                                                             }
                                             });
            container.CreateAndAddDescriptionRow("* Fields required/used only for User-Defined materials");
            tbr.ReadOnly  = section.Material != flowsheet.GetTranslatedString("UserDefined");
            tbtc.ReadOnly = tbr.ReadOnly;
            if (tbr.ReadOnly)
            {
                tbr.BackgroundColor  = Eto.Drawing.Colors.LightGrey;
                tbtc.BackgroundColor = Eto.Drawing.Colors.LightGrey;
            }
            else
            {
                tbr.BackgroundColor  = Eto.Drawing.SystemColors.ControlBackground;
                tbtc.BackgroundColor = Eto.Drawing.SystemColors.ControlBackground;
            }
            cbm.SelectedValueChanged += (sender, e) =>
            {
                if (cbm.SelectedValue.ToString() == flowsheet.GetTranslatedString("UserDefined"))
                {
                    tbr.ReadOnly         = false;
                    tbtc.ReadOnly        = false;
                    tbr.BackgroundColor  = Eto.Drawing.SystemColors.ControlBackground;
                    tbtc.BackgroundColor = Eto.Drawing.SystemColors.ControlBackground;
                    tbr.Text             = section.PipeWallRugosity.ConvertFromSI(su.distance).ToString(nf);
                    tbtc.Text            = section.PipeWallThermalConductivityExpression;
                    tbtc.TextAlignment   = TextAlignment.Left;
                }
                else
                {
                    tbr.ReadOnly         = true;
                    tbtc.ReadOnly        = true;
                    tbr.BackgroundColor  = Eto.Drawing.Colors.LightGrey;
                    tbtc.BackgroundColor = Eto.Drawing.Colors.LightGrey;
                    tbr.Text             = pipe.rugosidade(cbm.SelectedValue.ToString(), section).ConvertFromSI(su.distance).ToString(nf);
                    if (pipe.GraphicObject.InputConnectors[0].IsAttached)
                    {
                        var stream = (MaterialStream)flowsheet.SimulationObjects[pipe.GraphicObject.InputConnectors[0].AttachedConnector.AttachedFrom.Name];
                        tbtc.Text = pipe.k_parede(cbm.SelectedValue.ToString(), stream.GetTemperature(), section).ConvertFromSI(su.thermalConductivity).ToString(nf);
                    }
                    else
                    {
                        tbtc.Text = pipe.k_parede(cbm.SelectedValue.ToString(), 298.15, section).ConvertFromSI(su.thermalConductivity).ToString(nf);
                    }
                    tbtc.TextAlignment = TextAlignment.Right;
                }
            };
        }
コード例 #3
0
ファイル: AboutBox.cs プロジェクト: Greg66/dwsim6
        public void Init()
        {
            int w = (int)(sf * 640);
            int h = (int)(sf * 480);

            var center = Screen.PrimaryScreen.WorkingArea.Center;

            center.X -= w / 2;
            center.Y -= h / 2;

            Location = new Point(center);

            ClientSize = new Size(w, h);

            Maximizable = false;

            Minimizable = false;

            Resizable = false;

            ShowInTaskbar = false;

            AddComponentInfo();
            AddComponentInfoN();

            string imgprefix = "DWSIM.UI.Forms.Resources.Icons.";

            Title = "AboutDWSIM".Localize();

            Icon = Eto.Drawing.Icon.FromResource(imgprefix + "DWSIM_ico.ico");

            var layout = new PixelLayout();

            string vtext = "Version".Localize() + " " + Assembly.GetExecutingAssembly().GetName().Version.Major.ToString() +
                           "." + Assembly.GetExecutingAssembly().GetName().Version.Minor.ToString() +
                           "." + Assembly.GetExecutingAssembly().GetName().Version.Build.ToString();

#if DEBUG
            vtext += "-" + File.GetLastWriteTimeUtc(Assembly.GetExecutingAssembly().Location).ToString();
#endif

            string crtext = Shared.AssemblyCopyright;

            layout.Add(new ImageView {
                Size = new Size((int)(sf * 100), (int)(sf * 100)), Image = new Bitmap(Eto.Drawing.Bitmap.FromResource(imgprefix + "DWSIM_ico.png"))
            }, 0, 0);
            layout.Add(new Label {
                Text = "DWSIM Simulator (Cross-Platform User Interface)", TextAlignment = TextAlignment.Left, Font = SystemFonts.Bold(null, FontDecoration.None)
            }, (int)(sf * 110), 0);
            layout.Add(new Label {
                Text = vtext, TextAlignment = TextAlignment.Left
            }, (int)(sf * 110), (int)(sf * 20));
            layout.Add(new Label {
                Text = crtext, TextAlignment = TextAlignment.Left
            }, (int)(sf * 110), (int)(sf * 40));

            string osinfo = "", clrinfo = "", meminfo = "";

            if (Application.Instance.Platform.IsMac)
            {
                var osversion = Environment.OSVersion.Version.ToString();
                switch (osversion)
                {
                case "11.0.0.0": osinfo = "Mac OS X Lion (v10.7.0)"; break;

                case "11.4.2.0": osinfo = "Mac OS X Lion (v10.7.5)"; break;

                case "12.0.0.0": osinfo = "OS X Mountain Lion (v10.8.0)"; break;

                case "13.0.0.0": osinfo = "OS X Mavericks (v10.9.0)"; break;

                case "13.4.0.0": osinfo = "OS X Mavericks (v10.9.5)"; break;

                case "14.0.0.0": osinfo = "OS X Yosemite (v10.10.0)"; break;

                case "14.5.0.0": osinfo = "OS X Yosemite (v10.10.5)"; break;

                case "15.0.0.0": osinfo = "OS X El Captain (v10.11.0)"; break;

                case "15.6.0.0": osinfo = "OS X El Captain (v10.11.6)"; break;

                case "16.0.0.0": osinfo = "macOS Sierra (v10.12.0)"; break;

                case "16.1.0.0": osinfo = "macOS Sierra (v10.12.1)"; break;

                case "16.3.0.0": osinfo = "macOS Sierra (v10.12.2)"; break;

                case "16.4.8.0": osinfo = "macOS Sierra (v10.12.3)"; break;

                case "16.5.3.0": osinfo = "macOS Sierra (v10.12.4)"; break;

                case "16.5.6.0": osinfo = "macOS Sierra (v10.12.5)"; break;

                case "16.7.1.2": osinfo = "macOS Sierra (v10.12.6)"; break;

                case "17.0.0.0": osinfo = "macOS High Sierra (v10.13.0)"; break;

                case "17.4.0.0": osinfo = "macOS High Sierra (v10.13.3)"; break;

                case "18.0.0.0": osinfo = "macOS Mojave (v10.14.0)"; break;

                case "18.2.0.0": osinfo = "macOS Mojave (v10.14.1-3)"; break;

                case "18.5.0.0": osinfo = "macOS Mojave (v10.14.4)"; break;

                case "18.6.0.0": osinfo = "macOS Mojave (v10.14.5)"; break;

                case "18.7.0.1": osinfo = "macOS Mojave (v10.14.6)"; break;

                case "19.0.0.0": osinfo = "macOS Catalina (v10.15)"; break;

                case "19.2.0.0": osinfo = "macOS Catalina (v10.15.2)"; break;

                case "19.3.0.0": osinfo = "macOS Catalina (v10.15.3)"; break;

                case "19.4.0.0": osinfo = "macOS Catalina (v10.15.4)"; break;

                case "19.5.0.0": osinfo = "macOS Catalina (v10.15.5)"; break;

                case "19.6.0.0": osinfo = "macOS Catalina (v10.15.7)"; break;

                case "20.0.0.0": osinfo = "macOS Big Sur (v11.0.0)"; break;

                case "20.1.0.0": osinfo = "macOS Big Sur (v11.0.1)"; break;

                case "20.3.0.0": osinfo = "macOS Big Sur (v11.1.0)"; break;

                default: osinfo = "macOS (v" + osversion + ")"; break;
                }
            }
            else
            {
                osinfo = Environment.OSVersion.ToString();
            }

            clrinfo = SharedClasses.Utility.GetRuntimeVersion();

            meminfo = (GC.GetTotalMemory(false) / 1024 / 1024).ToString("#") + " MB managed, " + (Environment.WorkingSet / 1024 / 1024).ToString("#") + " MB total";

            var container1 = new DynamicLayout()
            {
                Padding = new Padding(10)
            };

            container1.CreateAndAddDescriptionRow("DWSIM is released under the terms of the GNU General Public License (GPL) version 3.");
            container1.CreateAndAddTwoLabelsRow2("OS Info:", osinfo);
            container1.CreateAndAddTwoLabelsRow2("CLR Info:", clrinfo);
            container1.CreateAndAddTwoLabelsRow2("Memory Usage:", meminfo);

            var listcontainer = new GridView {
                DataStore = components, RowHeight = (int)(sf * 20)
            };
            var listcontainern = new GridView {
                DataStore = componentsn, RowHeight = (int)(sf * 20)
            };

            var col1 = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.Name)
                },
                HeaderText = "Name"
            };
            col1.AutoSize = true;
            listcontainer.Columns.Add(col1);
            var col1a = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.Version)
                },
                HeaderText = "Version"
            };
            col1a.AutoSize = true;
            listcontainer.Columns.Add(col1a);
            var col1b = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.Year)
                },
                HeaderText = "Year"
            };
            col1b.AutoSize = true;
            listcontainer.Columns.Add(col1b);
            var col1c = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.Copyright)
                },
                HeaderText = "Copyright"
            };
            col1c.AutoSize = true;
            listcontainer.Columns.Add(col1c);
            var col1d = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.Website)
                },
                HeaderText = "Website"
            };
            col1d.AutoSize = true;
            listcontainer.Columns.Add(col1d);
            var col1e = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.License)
                },
                HeaderText = "License"
            };
            col1e.AutoSize = true;
            listcontainer.Columns.Add(col1e);
            var col1f = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.LicenseText)
                },
                HeaderText = "License Text"
            };
            col1f.AutoSize = true;
            listcontainer.Columns.Add(col1f);


            var col1n = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.Name)
                },
                HeaderText = "Name"
            };
            col1n.AutoSize = true;
            listcontainern.Columns.Add(col1n);
            var col1an = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.Version)
                },
                HeaderText = "Version"
            };
            col1an.AutoSize = true;
            listcontainern.Columns.Add(col1an);
            var col1fn = new GridColumn
            {
                DataCell = new TextBoxCell {
                    Binding = Binding.Property <ComponentInfo, string>(r => r.LicenseText)
                },
                HeaderText = "License Text"
            };
            col1fn.AutoSize = true;
            listcontainern.Columns.Add(col1fn);

            string gpltext;
            using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("DWSIM.UI.Forms.Resources.TextFiles.gpl-3.0.txt"))
                using (StreamReader reader = new StreamReader(stream))
                {
                    gpltext = reader.ReadToEnd();
                }

            var txt1 = new TextArea {
                Text = gpltext, ReadOnly = true, Font = Fonts.Monospace(10.0f)
            };

            var t1 = new TableLayout(new TableRow(txt1));

            var tab1 = new TabPage {
                Content = container1, Text = "General Information"
            };
            var tab2 = new TabPage {
                Content = new Scrollable {
                    Content = t1
                }, Text = "GPLv3 License"
            };
            var tab3 = new TabPage {
                Content = new Scrollable {
                    Content = listcontainer
                }, Text = "External Components"
            };
            var tab4 = new TabPage {
                Content = new Scrollable {
                    Content = listcontainern
                }, Text = "NuGet Packages"
            };

            var tabc = new TabControl();
            tabc.Pages.Add(tab1);
            tabc.Pages.Add(tab2);
            tabc.Pages.Add(tab3);
            tabc.Pages.Add(tab4);

            var tablecontainer = new TableLayout {
                Padding = new Padding(10), Spacing = new Size(5, 5)
            };

            tablecontainer.Rows.Add(new TableRow(layout));
            tablecontainer.Rows.Add(new TableRow(tabc));

            Content = tablecontainer;
        }
コード例 #4
0
        void Initialize()
        {
            container.CreateAndAddLabelRow("Reaction ID");

            container.CreateAndAddStringEditorRow2("Name", "", rx.Name, (sender, e) => { rx.Name = sender.Text; });

            container.CreateAndAddLabelRow("Compounds and Stoichiometry (Include / Name / Heat of Formation (kJ/kg) / Stoich. Coeff.)");

            var compcontainer = new DynamicLayout();
            //compcontainer.BackgroundColor = Colors.White;

            Double val;

            foreach (ICompoundConstantProperties comp in flowsheet.SelectedCompounds.Values)
            {
                var chk = new CheckBox()
                {
                    Text = comp.Name, Checked = (rx.Components.ContainsKey(comp.Name) ? true : false)
                };
                chk.CheckedChanged += (sender, e) =>
                {
                    if (!rx.Components.ContainsKey(comp.Name))
                    {
                        rx.Components.Add(comp.Name, new DWSIM.Thermodynamics.BaseClasses.ReactionStoichBase(comp.Name, 0, false, 0, 0));
                    }
                    else
                    {
                        rx.Components.Remove(comp.Name);
                    }
                    UpdateEquation();
                };

                var sc = new TextBox()
                {
                    Width = (int)(sf * 50), Text = (rx.Components.ContainsKey(comp.Name) ? rx.Components[comp.Name].StoichCoeff.ToString() : 0.0f.ToString())
                };

                sc.TextChanged += (sender, e) =>
                {
                    if (Double.TryParse(sc.Text.ToString(), out val))
                    {
                        sc.TextColor = SystemColors.ControlText;
                        if (!rx.Components.ContainsKey(comp.Name))
                        {
                            rx.Components.Add(comp.Name, new DWSIM.Thermodynamics.BaseClasses.ReactionStoichBase(comp.Name, Double.Parse(sc.Text), false, 0, 0));
                        }
                        else
                        {
                            rx.Components[comp.Name].StoichCoeff = double.Parse(sc.Text);
                        }
                        UpdateEquation();
                    }
                    else
                    {
                        sc.TextColor = Colors.Red;
                    }
                };


                var hf = new TextBox()
                {
                    Enabled = false, Width = (int)(sf * 100), Text = comp.IG_Enthalpy_of_Formation_25C.ToString("N2")
                };

                compcontainer.Add(new TableRow(chk, null, hf, sc));
            }

            container.CreateAndAddControlRow(compcontainer);
            container.CreateAndAddEmptySpace();

            var comps = flowsheet.SelectedCompounds.Values.Select((x) => x.Name).ToList();

            comps.Insert(0, "");

            container.CreateAndAddLabelRow("Base Compound");

            var basecompselector = container.CreateAndAddDropDownRow("Base Compound", comps, 0, null);

            var basecomp = rx.Components.Values.Where((x) => x.IsBaseReactant).FirstOrDefault();

            if (basecomp != null)
            {
                basecompselector.SelectedIndex = comps.IndexOf(basecomp.CompName);
            }
            else
            {
                basecompselector.SelectedIndex = 0;
            }

            basecompselector.SelectedIndexChanged += (sender, e) =>
            {
                if (rx.Components.ContainsKey(comps[basecompselector.SelectedIndex]))
                {
                    foreach (var rxc in rx.Components.Values)
                    {
                        rxc.IsBaseReactant = false;
                    }
                    rx.Components[comps[basecompselector.SelectedIndex]].IsBaseReactant = true;
                    rx.BaseReactant = comps[basecompselector.SelectedIndex];
                }
            };

            container.CreateAndAddLabelRow("Reaction Balance");

            txtEquation = container.CreateAndAddLabelRow2("");

            container.CreateAndAddLabelRow("Reaction Phase");

            var rxphaseselector = container.CreateAndAddDropDownRow("Reaction Phase", Shared.StringArrays.reactionphase().ToList(), 0, null);

            switch (rx.ReactionPhase)
            {
            case Interfaces.Enums.PhaseName.Mixture:
                rxphaseselector.SelectedIndex = 0;
                break;

            case Interfaces.Enums.PhaseName.Vapor:
                rxphaseselector.SelectedIndex = 1;
                break;

            case Interfaces.Enums.PhaseName.Liquid:
                rxphaseselector.SelectedIndex = 2;
                break;
            }

            rxphaseselector.SelectedIndexChanged += (sender, e) =>
            {
                switch (rxphaseselector.SelectedIndex)
                {
                case 0:
                    rx.ReactionPhase = Interfaces.Enums.PhaseName.Mixture;
                    break;

                case 1:
                    rx.ReactionPhase = Interfaces.Enums.PhaseName.Vapor;
                    break;

                case 2:
                    rx.ReactionPhase = Interfaces.Enums.PhaseName.Liquid;
                    break;
                }
            };

            container.CreateAndAddLabelRow("Reaction Basis");

            var rxbasisselector = container.CreateAndAddDropDownRow("Reaction Basis", Shared.StringArrays.reactionbasis().ToList(), 0, null);

            switch (rx.ReactionBasis)
            {
            case Interfaces.Enums.ReactionBasis.Activity:
                rxbasisselector.SelectedIndex = (0);
                break;

            case Interfaces.Enums.ReactionBasis.Fugacity:
                rxbasisselector.SelectedIndex = (1);
                break;

            case Interfaces.Enums.ReactionBasis.MassConc:
                rxbasisselector.SelectedIndex = (2);
                break;

            case Interfaces.Enums.ReactionBasis.MassFrac:
                rxbasisselector.SelectedIndex = (3);
                break;

            case Interfaces.Enums.ReactionBasis.MolarConc:
                rxbasisselector.SelectedIndex = (4);
                break;

            case Interfaces.Enums.ReactionBasis.MolarFrac:
                rxbasisselector.SelectedIndex = (5);
                break;

            case Interfaces.Enums.ReactionBasis.PartialPress:
                rxbasisselector.SelectedIndex = (6);
                break;
            }

            rxbasisselector.SelectedIndexChanged += (sender, e) =>
            {
                switch (rxbasisselector.SelectedIndex)
                {
                case 0:
                    rx.ReactionBasis = Interfaces.Enums.ReactionBasis.Activity;
                    break;

                case 1:
                    rx.ReactionBasis = Interfaces.Enums.ReactionBasis.Fugacity;
                    break;

                case 2:
                    rx.ReactionBasis = Interfaces.Enums.ReactionBasis.MassConc;
                    break;

                case 3:
                    rx.ReactionBasis = Interfaces.Enums.ReactionBasis.MassFrac;
                    break;

                case 4:
                    rx.ReactionBasis = Interfaces.Enums.ReactionBasis.MolarConc;
                    break;

                case 5:
                    rx.ReactionBasis = Interfaces.Enums.ReactionBasis.MolarFrac;
                    break;

                case 6:
                    rx.ReactionBasis = Interfaces.Enums.ReactionBasis.PartialPress;
                    break;
                }
            };

            container.CreateAndAddLabelRow("Rate Expressions");

            container.CreateAndAddLabelRow2("Reaction Rate Numerator Expression:");

            container.CreateAndAddMultilineTextBoxRow(rx.RateEquationNumerator, false, false, (sender, e) => rx.RateEquationNumerator = sender.Text);

            container.CreateAndAddLabelRow2("Reaction Rate Denominator Expression:");

            container.CreateAndAddMultilineTextBoxRow(rx.RateEquationDenominator, false, false, (sender, e) => rx.RateEquationDenominator = sender.Text);

            container.CreateAndAddDescriptionRow("Reaction Rate (r) = f(T, Ri, Pi) = Numerator / Denominator");

            container.CreateAndAddDescriptionRow("Expression Variables: Temperature (T) in K, reactant amounts (R1, R2, ..., Rn) and product amounts (P1, P2, ..., Pn in the selected amount units, Reaction Rate (r) in the selected velocity units.");

            container.CreateAndAddLabelRow("Units");

            var us    = new DWSIM.SharedClasses.SystemsOfUnits.Units();
            var units = us.GetUnitSet(Interfaces.Enums.UnitOfMeasure.molar_conc);

            units.AddRange(us.GetUnitSet(Interfaces.Enums.UnitOfMeasure.mass_conc));
            units.AddRange(us.GetUnitSet(Interfaces.Enums.UnitOfMeasure.pressure));
            units.Insert(0, "");

            container.CreateAndAddDropDownRow("Amount Units", units, units.IndexOf(rx.ConcUnit), (sender, e) => rx.ConcUnit = sender.SelectedValue.ToString());

            var units2 = us.GetUnitSet(Interfaces.Enums.UnitOfMeasure.reac_rate_heterog);

            units2.Insert(0, "");

            container.CreateAndAddDropDownRow("Velocity Units", units2, units2.IndexOf(rx.VelUnit), (sender, e) => rx.VelUnit = sender.SelectedValue.ToString());

            UpdateEquation();
        }
コード例 #5
0
ファイル: PipeSection.cs プロジェクト: Greg66/dwsim6
        void Initialize()
        {
            var su = flowsheet.FlowsheetOptions.SelectedUnitSystem;
            var nf = flowsheet.FlowsheetOptions.NumberFormat;

            if (section.TipoSegmento == "Tubulaosimples")
            {
                section.TipoSegmento = "Straight Tube Section";
            }

            var lblseg = container.CreateAndAddTwoLabelsRow("Segment", section.Indice.ToString());

            container.CreateAndAddDropDownRow("Type", sectypes, Array.IndexOf(sectypes.ToArray(), section.TipoSegmento), (sender, e) => section.TipoSegmento = sectypes[sender.SelectedIndex]);
            var cbm = container.CreateAndAddDropDownRow("Material", materials, Array.IndexOf(materials.ToArray(), section.Material), (sender, e) => section.Material = materials[sender.SelectedIndex]);
            var tbr = container.CreateAndAddTextBoxRow("G8", "Rugosity " + " (" + su.distance + ") *", cv.ConvertFromSI(su.distance, section.PipeWallRugosity), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                                                 {
                                                                                                                                                                                     section.PipeWallRugosity = cv.ConvertToSI(su.distance, sender.Text.ParseExpressionToDouble());
                                                                                                                                                                                 }
                                                       });
            var tbtc = container.CreateAndAddStringEditorRow("Thermal Conductivity " + " (" + su.thermalConductivity + ") *", section.PipeWallThermalConductivityExpression, (sender, e) => { section.PipeWallThermalConductivityExpression = sender.Text.ToString(); });

            container.CreateAndAddDescriptionRow("* Fields required/used only for User-Defined materials");
            container.CreateAndAddTextBoxRow("N0", "Increments", section.Incrementos, (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                       {
                                                                                                           section.Incrementos = int.Parse(sender.Text.ToString());
                                                                                                       }
                                             });
            container.CreateAndAddTextBoxRow("N0", "Quantity", section.Quantidade, (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                    {
                                                                                                        section.Quantidade = int.Parse(sender.Text.ToString());
                                                                                                    }
                                             });
            container.CreateAndAddTextBoxRow(nf, "Length" + " (" + su.distance + ")", cv.ConvertFromSI(su.distance, section.Comprimento), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                           {
                                                                                                                                                               section.Comprimento = cv.ConvertToSI(su.distance, sender.Text.ParseExpressionToDouble());
                                                                                                                                                           }
                                             });
            container.CreateAndAddTextBoxRow(nf, "Elevation" + " (" + su.distance + ")", cv.ConvertFromSI(su.distance, section.Elevacao), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                           {
                                                                                                                                                               section.Elevacao = cv.ConvertToSI(su.distance, sender.Text.ParseExpressionToDouble());
                                                                                                                                                           }
                                             });
            var edtb = container.CreateAndAddTextBoxRow(nf, "External Diameter" + " (" + su.diameter + ")", cv.Convert("in", su.diameter, section.DE), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                                        {
                                                                                                                                                                            section.DE = cv.Convert(su.diameter, "in", sender.Text.ParseExpressionToDouble());
                                                                                                                                                                        }
                                                        });
            var idtb = container.CreateAndAddTextBoxRow(nf, "Internal Diameter" + " (" + su.diameter + ")", cv.Convert("in", su.diameter, section.DI), (sender, e) => { if (sender.Text.IsValidDoubleExpression())
                                                                                                                                                                        {
                                                                                                                                                                            section.DI = cv.Convert(su.diameter, "in", sender.Text.ParseExpressionToDouble());
                                                                                                                                                                        }
                                                        });

            var ssizes = Pipe.GetStandardPipeSizes();

            var cmenussizes = new ContextMenu();

            foreach (var key in ssizes.Keys)
            {
                var mi = new ButtonMenuItem {
                    Text = key
                };
                foreach (var item in ssizes[key])
                {
                    var mi2 = new ButtonMenuItem
                    {
                        Text = item.StandardSizeDescription + " (OD = " +
                               item.ExternalDiameter_Inches + " in., ID = " +
                               item.InternalDiameter_Inches + " in.)"
                    };
                    mi2.Click += (s, e) =>
                    {
                        flowsheet.RunCodeOnUIThread(() =>
                        {
                            edtb.Text = item.ExternalDiameter_Inches.ConvertUnits("in", su.diameter).ToString(nf);
                            idtb.Text = item.InternalDiameter_Inches.ConvertUnits("in", su.diameter).ToString(nf);
                        });
                    };
                    mi.Items.Add(mi2);
                }
                cmenussizes.Items.Add(mi);
            }

            container.CreateAndAddButtonRow("Standard Pipe Sizes...", null, (btn, ev) =>
            {
                cmenussizes.Show(btn);
            });

            tbr.ReadOnly  = section.Material != flowsheet.GetTranslatedString("UserDefined");
            tbtc.ReadOnly = tbr.ReadOnly;
            if (tbr.ReadOnly)
            {
                tbr.BackgroundColor  = Eto.Drawing.Colors.LightGrey;
                tbtc.BackgroundColor = Eto.Drawing.Colors.LightGrey;
            }
            else
            {
                tbr.BackgroundColor  = Eto.Drawing.SystemColors.ControlBackground;
                tbtc.BackgroundColor = Eto.Drawing.SystemColors.ControlBackground;
            }
            cbm.SelectedValueChanged += (sender, e) =>
            {
                if (cbm.SelectedValue.ToString() == flowsheet.GetTranslatedString("UserDefined"))
                {
                    tbr.ReadOnly         = false;
                    tbtc.ReadOnly        = false;
                    tbr.BackgroundColor  = Eto.Drawing.SystemColors.ControlBackground;
                    tbtc.BackgroundColor = Eto.Drawing.SystemColors.ControlBackground;
                    tbr.Text             = section.PipeWallRugosity.ConvertFromSI(su.distance).ToString(nf);
                    tbtc.Text            = section.PipeWallThermalConductivityExpression;
                    tbtc.TextAlignment   = TextAlignment.Left;
                }
                else
                {
                    tbr.ReadOnly         = true;
                    tbtc.ReadOnly        = true;
                    tbr.BackgroundColor  = Eto.Drawing.Colors.LightGrey;
                    tbtc.BackgroundColor = Eto.Drawing.Colors.LightGrey;
                    tbr.Text             = pipe.GetRugosity(cbm.SelectedValue.ToString(), section).ConvertFromSI(su.distance).ToString(nf);
                    if (pipe.GraphicObject != null && pipe.GraphicObject.InputConnectors[0].IsAttached)
                    {
                        var stream = (MaterialStream)flowsheet.SimulationObjects[pipe.GraphicObject.InputConnectors[0].AttachedConnector.AttachedFrom.Name];
                        tbtc.Text = pipe.k_parede(cbm.SelectedValue.ToString(), stream.GetTemperature(), section).ConvertFromSI(su.thermalConductivity).ToString(nf);
                    }
                    else
                    {
                        tbtc.Text = pipe.k_parede(cbm.SelectedValue.ToString(), 298.15, section).ConvertFromSI(su.thermalConductivity).ToString(nf);
                    }
                    tbtc.TextAlignment = TextAlignment.Right;
                }
            };
        }
コード例 #6
0
ファイル: PIDTuningTool.cs プロジェクト: up2038292/dwsim6
        public PIDTuningTool(Shared.Flowsheet fs, DynamicsIntegratorControl intcontrol) : base()
        {
            Flowsheet = fs;
            intc      = intcontrol;
            Padding   = new Eto.Drawing.Padding(5);
            Spacing   = new Size(5, 5);

            Padding = new Eto.Drawing.Padding(5);
            Spacing = new Size(10, 10);

            var leftcontainer = new DynamicLayout {
                Width = 300
            };

            leftcontainer.CreateAndAddLabelRow("Schedule");

            var schlist = Flowsheet.DynamicsManager.ScheduleList.Values.ToList();

            var cbSchedule = leftcontainer.CreateAndAddDropDownRow("Schedule", schlist.Select((x) => x.Description).ToList(), 0,
                                                                   (dd, e) => schedule = schlist[dd.SelectedIndex]);

            leftcontainer.CreateAndAddLabelRow("Controllers");

            leftcontainer.CreateAndAddDescriptionRow("Select the PID Controllers to tune.");

            var listb = new CheckBoxList()
            {
                Height = 200
            };

            foreach (var obj in Flowsheet.SimulationObjects.Values.Where((x) => x.ObjectClass == Interfaces.Enums.SimulationObjectClass.Controllers))
            {
                listb.Items.Add(obj.GraphicObject.Tag, obj.Name);
            }

            leftcontainer.CreateAndAddControlRow(listb);

            leftcontainer.CreateAndAddNumericEditorRow("Maximum Iterations", iterations, 5, 100, 0,
                                                       (ns, e) =>
            {
                iterations = (int)ns.Value;
            });

            var btnRun = leftcontainer.CreateAndAddButtonRow("Begin Tuning", null, null);

            var btnCancel = leftcontainer.CreateAndAddButtonRow("Cancel", null, (btn, e) => Abort = true);

            txtResults = new TextArea {
                ReadOnly = true, Wrap = true
            };

            Rows.Add(new TableRow(leftcontainer, new Scrollable {
                Content = txtResults
            }));

            btnRun.Click += (s, e) =>
            {
                Flowsheet.RunCodeOnUIThread(() =>
                {
                    txtResults.Text = "";

                    if (!Flowsheet.DynamicMode)
                    {
                        txtResults.Text += "Error: Dynamic Mode is not activated. Activate Dynamic Mode and try again.";
                        return;
                    }

                    intc.cbsc.SelectedIndex = cbSchedule.SelectedIndex;

                    var schedule = Flowsheet.DynamicsManager.ScheduleList[Flowsheet.DynamicsManager.CurrentSchedule];

                    List <OptSimplexBoundVariable> vars = new List <OptSimplexBoundVariable>();
                    List <PIDController> controllers    = new List <PIDController>();

                    foreach (var item in listb.SelectedKeys)
                    {
                        var controller = (PIDController)Flowsheet.SimulationObjects[item];
                        controllers.Add(controller);
                        vars.Add(new OptSimplexBoundVariable(controller.Kp, 0.0, controller.Kp * 10));
                        vars.Add(new OptSimplexBoundVariable(controller.Ki, 0.0, 100.0));
                        vars.Add(new OptSimplexBoundVariable(controller.Kd, 0.0, 100.0));
                    }

                    btnRun.Enabled    = false;
                    btnCancel.Enabled = true;

                    Simplex simplex = new Simplex();

                    simplex.MaxFunEvaluations = iterations;

                    Abort = false;

                    int counter = 1;

                    if (schedule.InitialFlowsheetStateID == "" | schedule.UseCurrentStateAsInitial)
                    {
                        txtResults.Text  += "The selected schedule must have a valid initial state to start from.";
                        btnRun.Enabled    = true;
                        btnCancel.Enabled = false;
                        return;
                    }

                    var result = simplex.ComputeMin(x =>
                    {
                        if (Abort)
                        {
                            return(0.0);
                        }
                        Flowsheet.RunCodeOnUIThread(() =>
                        {
                            txtResults.Text += (string.Format("Beginning Iteration #{0}...\n", counter));
                        });
                        intc.RestoreState(schedule.InitialFlowsheetStateID);
                        var i = 0;
                        foreach (var controller in controllers)
                        {
                            controller.Kp = x[i];
                            controller.Ki = x[i + 1];
                            controller.Kd = x[i + 2];
                            Flowsheet.RunCodeOnUIThread(() =>
                            {
                                txtResults.Text += (string.Format("Controller: {0} - Kp = {1}, Ki = {2}, Kd = {3}\n", controller.GraphicObject.Tag, controller.Kp, controller.Ki, controller.Kd));
                            });
                            i += 3;
                        }
                        intc.RunIntegrator(false, true);
                        var totalerror = controllers.Select(c => c.CumulativeError).ToArray().AbsSumY();
                        Flowsheet.RunCodeOnUIThread(() =>
                        {
                            txtResults.Text      += (string.Format("Total Error: {0}\n", totalerror));
                            txtResults.CaretIndex = txtResults.Text.Length - 1;
                        });
                        Application.Instance.RunIteration();
                        counter += 1;
                        return(totalerror);
                    }, vars.ToArray());

                    if (Abort)
                    {
                        txtResults.Text += (string.Format("Tuning aborted by the user. Results:\n"));
                    }
                    else
                    {
                        txtResults.Text += (string.Format("Tuning finished successfully. Results:\n"));
                    }

                    var j = 0;
                    foreach (var controller in controllers)
                    {
                        controller.Kp    = result[j];
                        controller.Ki    = result[j + 1];
                        controller.Kd    = result[j + 2];
                        txtResults.Text += (string.Format("Controller: {0} - Kp = {1}, Ki = {2}, Kd = {3}\n", controller.GraphicObject.Tag, controller.Kp, controller.Ki, controller.Kd));
                        j += 3;
                    }

                    btnRun.Enabled    = true;
                    btnCancel.Enabled = false;

                    Flowsheet.UpdateInterface();
                });
            };
        }