23.3.0

FemDesign.Core/Calculate/Comb.cs

@@ -9,7 +9,6 @@ namespace FemDesign.Calculate
 
     /// <summary>
     /// fdscript.xsd
-    /// ANALCOMB
     /// </summary>
     public partial class Comb
     {
@@ -114,25 +113,6 @@ public Comb()
 
         }
 
-        [Obsolete("Use the other constructor. It will be removed in 23.3.0", false)]
-        public Comb(int _NLEmaxiter = 30, int _PLdefloadstep = 20, int _PLminloadstep = 2, int _PLmaxeqiter = 30, bool _NLSMohr = true, int _NLSinitloadstep = 10, int _NLSminloadstep = 10, int _NLSactiveelemratio = 5, int _NLSplasticelemratio = 5, int _CRloadstep = 20, int _CRmaxiter = 30, int _CRstifferror = 2, List<CombItem> combItem = null)
-        {
-            this.NLEmaxiter = _NLEmaxiter;
-            this.PLdefloadstep = _PLdefloadstep;
-            this.PLminloadstep = _PLminloadstep;
-            this.PLmaxeqiter = _PLmaxeqiter;
-            this.NLSMohr = _NLSMohr;
-            this.NLSinitloadstep = _NLSinitloadstep;
-            this.NLSminloadstep = _NLSminloadstep;
-            this.NLSactiveelemratio = _NLSactiveelemratio;
-            this.NLSplasticelemratio = _NLSplasticelemratio;
-            this.CRloadstep = _CRloadstep;
-            this.CRmaxiter = _CRmaxiter;
-            this.CRstifferror = _CRstifferror;
-
-            this.CombItem = combItem ?? new List<CombItem>();
-        }
-
         public Comb(int nLEmaxiter = 30, int pLdefloadstep = 20, int pLminloadstep = 2, bool plKeepLoadStep = true, int plTolerance = 1, int pLmaxeqiter = 50, int plShellLayers = 10, bool nLSMohr = true, int nLSinitloadstep = 10, int nLSminloadstep = 10, int nLSactiveelemratio = 5, int nLSplasticelemratio = 5, int cRloadstep = 20, int cRmaxiter = 30, int cRstifferror = 2, List<CombItem> combItem = null)
         {
             NLEmaxiter = nLEmaxiter;

FemDesign.Core/Calculate/CombItem.cs

@@ -13,72 +13,129 @@ namespace FemDesign.Calculate
     [System.Serializable]
     public partial class CombItem
     {
+        [XmlAttribute("Calc")]
+        public int _calc { get; set; } = 1;
+
+        /// <summary>
+        /// Calculate load combination (linear analysis).
+        /// </summary>
+        [XmlIgnore]
+        public bool Calc
+        {
+            get 
+            { 
+                return Convert.ToBoolean(_calc); 
+            }
+            set 
+            { 
+                _calc = Convert.ToInt32(value);
+                if(!value)
+                {
+                    NLE = PL = NLS = Cr = f2nd = false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Write only property. If true, no calculations will be executed for load combinations.
+        /// </summary>
+        [XmlIgnore]
+        public bool NoCalc
+        {
+            set
+            {
+                Calc = !value;
+            }
+        }
+
         [XmlAttribute("NLE")]
-        public bool _nle { get; set; }
+        public int _nle { get; set; }
 
         /// <summary>
         /// Consider elastic nonlinear behaviour of structural elements.
         /// </summary>
         [XmlIgnore]
         public bool NLE
         {
-            get { return _nle; }
-            set { _nle = value; }
+            get 
+            { 
+                return Convert.ToBoolean(_nle); 
+            }
+            set 
+            { 
+                _nle = Convert.ToInt32(value);
+                if(!value)
+                    PL = false;
+            }
         }
 
 
         [XmlAttribute("PL")]
-        public bool _pl { get; set; }
+        public int _pl { get; set; }
 
         /// <summary>
         /// Consider plastic behaviour of structural elements.
         /// </summary>
         [XmlIgnore]
         public bool PL
         {
-            get { return _pl; }
-            set { _pl = value; }
+            get 
+            { 
+                return Convert.ToBoolean(_pl); 
+            }
+            set 
+            { 
+                _pl = Convert.ToInt32(value);
+                if (value) NLE = true; 
+            }
         }
 
 
         [XmlAttribute("NLS")]
-        public bool _nls { get; set; }
+        public int _nls { get; set; }
 
         /// <summary>
         /// Consider nonlinear behaviour of soil.
         /// </summary>
         [XmlIgnore]
         public bool NLS
         {
-            get { return _nls; }
-            set { _nls = value; }
+            get { return Convert.ToBoolean(_nls); }
+            set { _nls = Convert.ToInt32(value); }
         }
 
         [XmlAttribute("Cr")]
-        public bool _cr { get; set; }
+        public int _cr { get; set; }
 
         /// <summary>
         /// Cracked section analysis. Note that Cr only executes properly in RCDesign with DesignCheck set to true.
         /// </summary>
         [XmlIgnore]
         public bool Cr
         {
-            get { return _cr; }
-            set { _cr = value; }
+            get 
+            { 
+                return Convert.ToBoolean(_cr); 
+            }
+            set 
+            { 
+                _cr = Convert.ToInt32(value);
+                if (value) PL = false;
+            }
         }
 
 
         [XmlAttribute("f2nd")]
-        public bool _f2nd { get; set; }
+        public int _f2nd { get; set; }
 
         /// <summary>
         /// 2nd order analysis.
         /// </summary>
         [XmlIgnore]
         public bool f2nd
         {
-            get { return _f2nd; }
-            set { _f2nd = value; }
+            get { return Convert.ToBoolean(_f2nd); }
+            set { _f2nd = Convert.ToInt32(value); }
         }
 
 
@@ -119,7 +176,7 @@ private CombItem()
         /// <param name="Cr">Cracked section analysis. Note that Cr only executes properly in RCDesign with DesignCheck set to true.</param>
         /// <param name="f2nd">2nd order analysis.</param>
         /// <param name="Im">Imperfection shape for 2nd order analysis.</param>
-        /// <param name="amplitude">Ground water level.</param>
+        /// <param name="amplitude">Amplitude of selected imperfection shape.</param>
         /// <param name="waterlevel">Ground water level.</param>
         // <param name="Amplitude">Amplitude of selected imperfection shape.</param> // TODO Amplitude?
         public CombItem(int impfRqd = 0, int stabReq = 0, bool NLE = true, bool PL = true, bool NLS = false, bool Cr = false, bool f2nd = false, int Im = 0, double amplitude = 0.0, int waterlevel = 0)
@@ -136,6 +193,21 @@ public CombItem(int impfRqd = 0, int stabReq = 0, bool NLE = true, bool PL = tru
             this.StabRqd = stabReq;
         }
 
+        /// <summary>
+        /// Load combination-specific settings for calculations.
+        /// </summary>
+        /// <param name="combName">Load combination name.</param>
+        /// <param name="impfRqd">Required imperfection shapes.</param >
+        /// <param name="stabReq">Required buckling shapes for stability analysis.</param>
+        /// <param name="NLE">Consider elastic nonlinear behaviour of structural elements.</param>
+        /// <param name="PL">Consider plastic behaviour of structural elements.</param>
+        /// <param name="NLS">Consider nonlinear behaviour of soil.</param>
+        /// <param name="Cr">Cracked section analysis. Note that Cr only executes properly in RCDesign with DesignCheck set to true.</param>
+        /// <param name="f2nd">2nd order analysis.</param>
+        /// <param name="Im">Imperfection shape for 2nd order analysis.</param>
+        /// <param name="amplitude">Amplitude of selected imperfection shape.</param>
+        /// <param name="waterlevel">Ground water level.</param>
+        // <param name="Amplitude">Amplitude of selected imperfection shape.</param> // TODO Amplitude?
         public CombItem(string combName, int impfRqd = 0, int stabReq = 0, bool NLE = true, bool PL = true, bool NLS = false, bool Cr = false, bool f2nd = false, int Im = 0, double amplitude = 0.0, int waterlevel = 0)
         {
             this.CombName = combName;

FemDesign.Core/Calculate/ExcitationForce.cs

@@ -0,0 +1,135 @@
+// https://strusoft.com/
+using FemDesign.GenericClasses;
+using System;
+using System.Xml.Serialization;
+
+namespace FemDesign.Calculate
+{
+    /// <summary>
+    /// fdscript.xsd
+    /// </summary>
+    public partial class ExcitationForce
+    {
+        [XmlAttribute("nres")]
+        public int _timeStep = 5;
+        [XmlIgnore]
+        public int TimeStep
+        {
+            get
+            {
+                return this._timeStep;
+            }
+            set
+            {
+                this._timeStep = value;
+            }
+        }
+
+        [XmlAttribute("tcend")]
+        public double _lastMomentOfThCalc = 20.0;
+        [XmlIgnore]
+        public double LastMomentOfThCalc
+        {
+            get
+            {
+                return this._lastMomentOfThCalc;
+            }
+            set
+            {
+                this._lastMomentOfThCalc = value;
+            }
+        }
+
+        [XmlAttribute("method")]
+        public int _method = 0;
+        [XmlIgnore]
+        public IntegrationSchemeMethod Method
+        {
+            get
+            {
+                return (IntegrationSchemeMethod)_method;
+            }
+            set
+            {
+                this._method = (int)value;
+            }
+        }
+
+        [XmlAttribute("alpha")]
+        public double _alpha = 0.0;
+        [XmlIgnore]
+        public double Alpha
+        {
+            get
+            {
+                return this._alpha;
+            }
+            set
+            {
+                this._alpha = value;
+            }
+        }
+
+        [XmlAttribute("beta")]
+        public double _beta = 0.0;
+        [XmlIgnore]
+        public double Beta
+        {
+            get
+            {
+                return this._beta;
+            }
+            set
+            {
+                this._beta = value;
+            }
+        }
+
+        [XmlAttribute("ksi")]
+        public double _dmpFactor = 5.0;
+        [XmlIgnore]
+        public double DmpFactor
+        {
+            get
+            {
+                return this._dmpFactor;
+            }
+            set
+            {
+                this._dmpFactor = value;
+            }
+        }
+
+        /// <summary>
+        /// Parameterless constructor for serialization.
+        /// </summary>
+        public ExcitationForce()
+        {
+
+        }
+
+        /// <summary>
+        /// Define calculation parameters for excitation force calculation.
+        /// </summary>
+        /// <param name="step">The number of every nth time steps when results are saved during the calculation.</param>
+        /// <param name="lastMoment">Last time moment of the time history calculation [s].</param>
+        /// <param name="method">Integration scheme method type.</param>
+        /// <param name="alpha">'alpha' coefficient in the Rayleigh damping matrix.</param>
+        /// <param name="beta">'beta' coefficient in the Rayleigh damping matrix.</param>
+        /// <param name="dampingFactor">'ksi' damping factor.</param>
+        public ExcitationForce(int step = 5, double lastMoment = 20.0, IntegrationSchemeMethod method = IntegrationSchemeMethod.Newmark, double alpha = 0, double beta = 0, double dampingFactor = 5.0)
+        {
+            this.TimeStep = step;
+            this.LastMomentOfThCalc = lastMoment;
+            this.Method = method;
+            this.Alpha = alpha;
+            this.Beta = beta;
+            this.DmpFactor = dampingFactor;
+        }
+
+        public static ExcitationForce Default()
+        {
+            return new ExcitationForce(5, 20.0, IntegrationSchemeMethod.Newmark, 0, 0, 5.0); 
+        }
+    }
+}