예제 #1
0
 public UniformLoadForPlanarElements(double ux, double uy, double uz, LoadCase lc)
     : base(lc)
 {
     _ux = ux;
     _uy = uy;
     _uz = uz;
 }
예제 #2
0
        /// <summary>
        /// Gets the total displacement vector for whole structure for specified <see cref="cse"/>
        /// </summary>
        /// <param name="cse">The cse.</param>
        /// <param name="map">The map.</param>
        /// <remarks>
        /// This is not used for finding unknown displacements (like displacement of free DoFs).
        /// Just is used for known displacements (like settlements and only for settlement).
        /// </remarks>
        /// <returns></returns>
        private double[] GetTotalDispVector(LoadCase cse, DofMappingManager map)
        {
            //displacement vector. free part can be assume zero however didn't touch that

            var n = parent.Nodes.Count;

            var buf = new double[6 * n];

            if (parent.SettlementLoadCase != cse)
            {
                return(buf);
            }

            var nodes = parent.Nodes;

            for (var i = 0; i < n; i++)
            {
                var disp = nodes[i].Settlements;

                buf[6 * i + 0] = disp.DX;
                buf[6 * i + 1] = disp.DY;
                buf[6 * i + 2] = disp.DZ;

                buf[6 * i + 3] = disp.RX;
                buf[6 * i + 4] = disp.RY;
                buf[6 * i + 5] = disp.RZ;
            }


            return(buf);
        }
예제 #3
0
        /// <summary>
        /// Gets the nodal displacement regarding defined load case
        /// </summary>
        /// <param name="cse">load case</param>
        /// <returns></returns>
        public Displacement GetNodalDisplacement(LoadCase cse)
        {
            parent.LastResult.AddAnalysisResultIfNotExists(cse);
            var disps = parent.LastResult.Displacements[cse];

            var buf = Displacement.FromVector(disps, this.Index * 6);

            return(buf);
        }
        /// <summary>
        /// Gets the total elements equivalent nodal force vector.
        /// </summary>
        /// <param name="cse">The load case.</param>
        /// <param name="map">The map.</param>
        /// <returns></returns>
        private double[] GetTotalElementsForceVector(LoadCase cse)
        {
            //force vector for both free and fixed dof

            var n = parent.Nodes.Count;

            var loads = new Force[n];   //loads from connected element to node is stored in this array instead of Node.ElementLoads.

            for (int i = 0; i < n; i++) //re indexing
            {
                parent.Nodes[i].Index = i;
            }

            #region adding element loads

            foreach (var elm in parent.Elements)
            {
                var nc = elm.Nodes.Length;

                foreach (var ld in elm.Loads)
                {
                    if (ld.Case != cse)
                    {
                        continue;
                    }

                    var frcs =
                        elm.GetGlobalEquivalentNodalLoads(ld);
                    //ld.GetGlobalEquivalentNodalLoads(elm);

                    for (var i = 0; i < nc; i++)
                    {
                        var nde = elm.Nodes[i];
                        loads[nde.Index] += frcs[i];
                    }
                }
            }

            #endregion


            var buf = new double[6 * n];
            for (int i = 0; i < n; i++)
            {
                var force = loads[i];

                buf[6 * i + 0] = force.Fx;
                buf[6 * i + 1] = force.Fy;
                buf[6 * i + 2] = force.Fz;

                buf[6 * i + 3] = force.Mx;
                buf[6 * i + 4] = force.My;
                buf[6 * i + 5] = force.Mz;
            }

            return(buf);
        }
예제 #5
0
        public static int[] GetMasterMapping(Model model, LoadCase cse, out bool[] hinged)
        {
            for (int i = 0; i < model.Nodes.Count; i++)
            {
                model.Nodes[i].Index = i;
            }


            var n       = model.Nodes.Count;
            var masters = new int[n];

            hinged = new bool[n];


            for (var i = 0; i < n; i++)
            {
                masters[i] = i;
            }

            var masterCount = 0;

            #region filling the masters

            var distinctElements = GetDistinctRigidElements(model, cse);

            var centralNodePrefreation = new bool[n];


            foreach (var elm in model.RigidElements)
            {
                if (elm.CentralNode != null)
                {
                    centralNodePrefreation[elm.CentralNode.Index] = true;
                }
            }


            foreach (var elm in distinctElements)
            {
                if (elm.Count == 0)
                {
                    continue;
                }

                var elmMasterIndex = GetMasterNodeIndex(model, elm, centralNodePrefreation);

                for (var i = 0; i < elm.Count; i++)
                {
                    masters[elm[i]] = elmMasterIndex;
                }
            }

            #endregion

            return(masters);
        }
예제 #6
0
        private Model(SerializationInfo info, StreamingContext context)
        {
            elements    = (ElementCollection)info.GetValue("elements", typeof(ElementCollection));
            mpcElements = (MpcElementCollection)info.GetValue("mpcElements", typeof(MpcElementCollection));

            rigidElements  = (RigidElementCollection)info.GetValue("rigidElements", typeof(RigidElementCollection));
            telepathyLinks = (TelepathyLinkCollection)info.GetValue("telepathyLinks", typeof(TelepathyLinkCollection));

            nodes = (NodeCollection)info.GetValue("nodes", typeof(NodeCollection));
            settlementLoadCase = (LoadCase)info.GetValue("settlementLoadCase", typeof(LoadCase));
        }
예제 #7
0
        public static CCS GetReducedFreeFreeStiffnessMatrix(this Model model,
                                                            LoadCase lc)
        {
            var fullst = MatrixAssemblerUtil.AssembleFullStiffnessMatrix(model);

            var mgr = DofMappingManager.Create(model, lc);

            var dvd = CalcUtil.GetReducedZoneDividedMatrix(fullst, mgr);

            return(dvd.ReleasedReleasedPart);
        }
예제 #8
0
        /// Gets the sum of external applying forces (including exnternal nodal loads + Equivalent nodal loads of elemental loads)
        /// </summary>
        /// <param name="loadCase">the load case</param>
        /// <returns></returns>
        public Force GetTotalApplyingForces(LoadCase loadCase)
        {
            parent.LastResult.AddAnalysisResultIfNotExists(loadCase);

            var cs = Force.FromVector(parent.LastResult.ConcentratedForces[loadCase], 6 * Index);
            var es = Force.FromVector(parent.LastResult.ElementForces[loadCase], 6 * Index);

            var buf = -cs - es;

            return(buf);
        }
        /// <summary>
        /// Determines whether the <see cref="Model"/> Needs the permutation for defined <see cref="loadCase"/> or not. (i.e. should model consider any <see cref="RigidElement"/> while analyzing the <see cref="loadCase"/> or not.)
        /// </summary>
        /// <param name="model">The model.</param>
        /// <param name="loadCase">The load case.</param>
        /// <returns>true, if need to consider any <see cref="RigidElement"/>; false, otherwise</returns>
        public static bool NeedPermutation(Model model, LoadCase loadCase)
        {
            foreach (var elm in model.RigidElements)
            {
                if (IsAppliableRigidElement(elm, loadCase))
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #10
0
        /// <summary>
        /// Gets the sum of external forces (including support reaction + exnternal nodal loads + Equivalent nodal loads of elemental loads)
        /// </summary>
        /// <param name="loadCase">the load case</param>
        /// <returns></returns>
        public Force GetTotalExternalForces(LoadCase loadCase)
        {
            parent.LastResult.AddAnalysisResultIfNotExists(loadCase);

            var cs = Force.FromVector(parent.LastResult.ConcentratedForces[loadCase], 6 * Index);
            var es = Force.FromVector(parent.LastResult.ElementForces[loadCase], 6 * Index);
            var ss = Force.FromVector(parent.LastResult.SupportReactions[loadCase], 6 * Index);

            var buf = ss - cs - es;

            return(buf);
        }
예제 #11
0
        public void AddAnalysisResultIfNotExists_MPC(LoadCase cse)
        {
            var f1 = _displacements.ContainsKey(cse);
            var f2 = _forces.ContainsKey(cse);

            if (f1 || f2)
            {
                return;
            }

            AddAnalysisResult_MPC(cse);
        }
예제 #12
0
        protected Model(SerializationInfo info, StreamingContext context)
        {
            Elements    = (ElementCollection)info.GetValue("elements", typeof(ElementCollection));
            MpcElements = (MpcElementCollection)info.GetValue("mpcElements", typeof(MpcElementCollection));

            rigidElements = (RigidElementCollection)info.GetValue("rigidElements", typeof(RigidElementCollection));
            //telepathyLinks = (TelepathyLinkCollection)info.GetValue("telepathyLinks", typeof(TelepathyLinkCollection));

            Nodes = (NodeCollection)info.GetValue("nodes", typeof(NodeCollection));
            settlementLoadCase = (LoadCase)info.GetValue("settlementLoadCase", typeof(LoadCase));

            InitPool();
        }
        /// <summary>
        /// Gets the nodal displacement regarding defined load case
        /// </summary>
        /// <param name="cse">load case</param>
        /// <returns></returns>
        internal void SetNodalDisplacement(LoadCase cse, Displacement disp)
        {
            if (parent.LastResult == null)
            {
                throw new Exception();
            }


            var disps = parent.LastResult.Displacements[cse];

            var vect = Displacement.ToVector(disp);

            Array.Copy(vect, 0, disps, this.Index * 6, 6);
        }
예제 #14
0
        /// <summary>
        /// Gets the total displacements with specified <see cref="loadCase"/>
        /// </summary>
        /// <param name="loadCase">the load case</param>
        /// <returns></returns>
        public Displacement GetTotalSettlementAmount(LoadCase loadCase)
        {
            var buf = new Displacement();

            foreach (var st in settlements)
            {
                if (st.LoadCase == loadCase)
                {
                    buf += st.Displacement;
                }
            }

            return(buf);
        }
        /// <summary>
        /// Analyses the stiffness matrix for warnings.
        /// </summary>
        /// <param name="mtx">The MTX.</param>
        /// <param name="map">The map.</param>
        /// <param name="currentCase">The current load case which error is with it.</param>
        /// <remarks>
        /// Only searches for zero elements on matrix diagonal
        /// </remarks>
        private void AnalyseStiffnessMatrixForWarnings(ZoneDevidedMatrix mtx, DofMappingManager map,
                                                       LoadCase currentCase)
        {
            var cs = mtx.ReleasedReleasedPart;

            var n = cs.ColumnCount;

            var t = new bool[n]; //true if i'th diagonal member nonzero, false if diagonal member zero!

            for (var i = 0; i < n; i++)
            {
                var st = cs.ColumnPointers[i];
                var en = cs.ColumnPointers[i + 1];

                var col = i;

                for (var j = st; j < en; j++)
                {
                    var row = cs.RowIndices[j];
                    //var val = cs.Values[j];

                    if (row == col)
                    {
                        t[row] = true;
                    }
                }
            }

            for (var i = 0; i < n; i++)
            {
                if (t[i])
                {
                    continue;
                }

                var globalDofNum = map.RMap1[map.RMap2[i]];

                var nodeNum = globalDofNum / 6;
                var dof     = (DoF)(globalDofNum % 6);

                var rec = TraceRecords.GetRecord(30000, parent.Nodes[nodeNum].Label);

                rec.TargetIdentifier = string.Format(
                    "{0} DoF on node #{1} for load case with [name = '{2}'] and [nature = {3}]", dof, nodeNum,
                    currentCase.CaseName, currentCase.LoadType);

                parent.Trace.Write(rec);
            }
        }
        /// <summary>
        /// Gets the total concentrated forces on loads vector.
        /// </summary>
        /// <param name="cse">The load case.</param>
        /// <param name="map">The map.</param>
        /// <returns></returns>
        private double[] GetTotalConcentratedForceVector(LoadCase cse)
        {
            //force vector for both free and fixed dof

            var n = parent.Nodes.Count;

            var loads = new Force[n];   //loads from connected element to node is stored in this array instead of Node.ElementLoads.

            for (int i = 0; i < n; i++) //re indexing
            {
                parent.Nodes[i].Index = i;
            }

            #region adding concentrated nodal loads

            for (int i = 0; i < n; i++)
            {
                foreach (var load in parent.Nodes[i].Loads)
                {
                    if (load.Case != cse)
                    {
                        continue;
                    }

                    loads[parent.Nodes[i].Index] += load.Force;
                }
            }

            #endregion


            var buf = new double[6 * n];
            for (int i = 0; i < n; i++)
            {
                var force = loads[i];

                buf[6 * i + 0] = force.Fx;
                buf[6 * i + 1] = force.Fy;
                buf[6 * i + 2] = force.Fz;

                buf[6 * i + 3] = force.Mx;
                buf[6 * i + 4] = force.My;
                buf[6 * i + 5] = force.Mz;
            }

            return(buf);
        }
예제 #17
0
        /// <summary>
        /// Generates the permutation for delta for specified model in specified loadCase.
        /// Note that delta permutation = P_delta in reduction process
        /// </summary>
        /// <param name="target">The target.</param>
        /// <param name="loadCase">The load case.</param>
        /// <returns>delta permutation</returns>
        public static CCS GenerateP_Delta(Model target, LoadCase loadCase)
        {
            throw new NotImplementedException();

            target.ReIndexNodes();

            var buf = new CoordinateStorage <double>(target.Nodes.Count * 6, target.Nodes.Count * 6, 1);


            #region rigid elements
            foreach (var elm in target.RigidElements)
            {
                var centralNode = elm.Nodes[0];
                var masterIdx   = centralNode.Index;

                for (var i = 1; i < elm.Nodes.Count; i++)
                {
                    var slaveIdx = elm.Nodes[i].Index;

                    var d = centralNode.Location - elm.Nodes[i].Location;

                    //buf[0, 4] = -(buf[1, 3] = d.Z);
                    //buf[2, 3] = -(buf[0, 5] = d.Y);
                    //buf[1, 5] = -(buf[2, 4] = d.X);

                    buf.At(6 * slaveIdx + 0, 6 * masterIdx + 0, 1);
                    buf.At(6 * slaveIdx + 1, 6 * masterIdx + 1, 1);
                    buf.At(6 * slaveIdx + 2, 6 * masterIdx + 2, 1);

                    buf.At(6 * slaveIdx + 1, 6 * masterIdx + 3, d.Z);
                    buf.At(6 * slaveIdx + 0, 6 * masterIdx + 4, -d.Z);

                    buf.At(6 * slaveIdx + 0, 6 * masterIdx + 5, d.Y);
                    buf.At(6 * slaveIdx + 2, 6 * masterIdx + 3, -d.Y); //

                    buf.At(6 * slaveIdx + 2, 6 * masterIdx + 4, d.X);  //
                    buf.At(6 * slaveIdx + 1, 6 * masterIdx + 5, -d.X);
                }
                //add to buf
            }
            #endregion

            throw new NotImplementedException();

            return(buf.ToCCs());
        }
예제 #18
0
        /// <summary>
        /// Adds the analysis result if not exists.
        /// </summary>
        /// <param name="cse">The load case.</param>
        /// <remarks>If current instance do not contains the results related to <see cref="cse"/>, then this method will add result related to <see cref="cse"/> using <see cref="StaticLinearAnalysisResult.AddAnalResult"/> method</remarks>
        public void AddAnalysisResultIfNotExists(LoadCase cse)
        {
            var f1 = displacements.ContainsKey(cse);
            var f2 = forces.ContainsKey(cse);

            if (f1 != f2)
            {
                throw new Exception("!");
            }

            if (f1)
            {
                return;
            }

            AddAnalysisResult(cse);
        }
예제 #19
0
파일: Node.cs 프로젝트: saegeoff/BFE.Net
        /// <summary>
        /// Gets the supports reaction that is from load cse which are applying to this <see cref="Node"/> from supports.
        /// </summary>
        /// <param name="cse">The loadCase.</param>
        /// <returns></returns>
        public Force GetSupportReaction(LoadCase cse)
        {
            if (constraints == Constraint.Released)
            {
                return(new Force());
            }


            parent.LastResult.AddAnalysisResultIfNotExists(cse);

            var cs = Force.FromVector(parent.LastResult.ConcentratedForces[cse], 6 * Index);
            var es = Force.FromVector(parent.LastResult.ElementForces[cse], 6 * Index);
            var ss = Force.FromVector(parent.LastResult.SupportReactions[cse], 6 * Index);

            var buf = ss - cs - es;

            if (constraints.DX == DofConstraint.Released)
            {
                buf.Fx = 0;
            }
            if (constraints.DY == DofConstraint.Released)
            {
                buf.Fy = 0;
            }
            if (constraints.DZ == DofConstraint.Released)
            {
                buf.Fz = 0;
            }


            if (constraints.RX == DofConstraint.Released)
            {
                buf.Mx = 0;
            }
            if (constraints.RY == DofConstraint.Released)
            {
                buf.My = 0;
            }
            if (constraints.RZ == DofConstraint.Released)
            {
                buf.Mz = 0;
            }

            return(buf);
        }
예제 #20
0
        public static bool IsInStaticEquilibrium(StaticLinearAnalysisResult res, LoadCase cse)
        {
            var allForces = new Force[res.Parent.Nodes.Count];


            var forceVec = res.Forces[cse];

            for (int i = 0; i < allForces.Length; i++)
            {
                var force = Force.FromVector(forceVec, 6 * i);
                allForces[i] = force;
            }


            var ft = allForces.Select((i, j) => i.Move(res.Parent.Nodes[j].Location, new Point())).Sum();

            throw new NotImplementedException();
        }
예제 #21
0
        private static bool IsAppliableRigidElement(RigidElement elm, LoadCase loadCase)
        {
            if (elm.UseForAllLoads)
            {
                return(true);
            }

            if (elm.AppliedLoadTypes.Contains(loadCase.LoadType))
            {
                return(true);
            }

            if (elm.AppliedLoadCases.Contains(loadCase))
            {
                return(true);
            }

            return(false);
        }
        public bool AppliesForLoadCase(LoadCase lc)
        {
            if (_useForAllLoads)
            {
                return(true);
            }

            if (AppliedLoadCases.Contains(lc))
            {
                return(true);
            }

            if (_appliedLoadTypes.Contains(lc.LoadType))
            {
                return(true);
            }

            return(false);
        }
예제 #23
0
        private static List <List <int> > GetDistinctRigidElements(Model model, LoadCase loadCase)
        {
            for (int i = 0; i < model.Nodes.Count; i++)
            {
                model.Nodes[i].Index = i;
            }

            var n = model.Nodes.Count;

            var ecrd = new CoordinateStorage <double>(n, n, 1); //for storing existence of rigid elements
            var crd  = new CoordinateStorage <double>(n, n, 1); //for storing hinged connection of rigid elements

            for (int ii = 0; ii < model.RigidElements.Count; ii++)
            {
                var elm = model.RigidElements[ii];

                if (IsAppliableRigidElement(elm, loadCase))
                {
                    for (var i = 0; i < elm.Nodes.Count; i++)
                    {
                        ecrd.At(elm.Nodes[i].Index, elm.Nodes[i].Index, 1.0);
                    }

                    for (var i = 0; i < elm.Nodes.Count - 1; i++)
                    {
                        ecrd.At(elm.Nodes[i].Index, elm.Nodes[i + 1].Index, 1.0);
                        ecrd.At(elm.Nodes[i + 1].Index, elm.Nodes[i].Index, 1.0);
                    }
                }
            }

            var graph = Converter.ToCompressedColumnStorage(ecrd);

            var buf = CalcUtil.EnumerateGraphParts(graph);

            return(buf);
        }
예제 #24
0
        /// <summary>
        /// Determines whether the specified <see cref="rigidElement"/> should be considered with defined <see cref="loadCase"/> or not.
        /// </summary>
        /// <param name="rigidElement">The rigidElement.</param>
        /// <param name="loadCase">The load case.</param>
        /// <returns></returns>
        private static bool IsAppliableRigidElement(RigidElement rigidElement, LoadCase loadCase)
        {
            return(true);

            if (rigidElement.UseForAllLoads)
            {
                return(true);
            }

            foreach (var lCase in rigidElement.AppliedLoadCases)
            {
                if (lCase.LoadType == loadCase.LoadType)
                {
                    return(true);
                }

                if (lCase.Equals(loadCase))
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #25
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LoadCase"/> struct.
 /// </summary>
 /// <param name="loadCase">load case of settlement.</param>
 /// <param name="displacement">amount of settlement.</param>
 public Settlement(LoadCase loadCase, Displacement displacement)
 {
     this.loadCase     = loadCase;
     this.displacement = displacement;
 }
예제 #26
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LoadCase"/> struct. for ISerialable.
 /// </summary>
 /// <param name="info">The information.</param>
 /// <param name="context">The context.</param>
 private Settlement(SerializationInfo info, StreamingContext context)
 {
     loadCase     = info.GetValue <LoadCase>("caseName");
     displacement = info.GetValue <Displacement>("loadType");
 }
예제 #27
0
        /// <summary>
        /// Gets the permutation matrix for defined <see cref="model" /> for applying the defined <see cref="RigidElement"/>s in <see cref="model"/> in defined <see cref="loadCase"/>.
        /// </summary>
        /// <param name="model">The model.</param>
        /// <param name="loadCase">The load case.</param>
        /// <returns>The permutation matrix</returns>
        public CompressedColumnStorage <double> GetPermutationMatrix(Model model, LoadCase loadCase)
        {
            for (int i = 0; i < model.Nodes.Count; i++)
            {
                model.Nodes[i].Index = i;
            }


            var n       = model.Nodes.Count;
            var masters = new int[n];

            for (var i = 0; i < n; i++)
            {
                masters[i] = i;
            }

            var masterCount = 0;

            #region filling the masters

            var distinctElements = GetDistinctRigidElements(model, loadCase);


            foreach (var elm in distinctElements)
            {
                if (elm.Count == 0)
                {
                    continue;
                }

                var elmMasterIndex = GetMasterNodeIndex(model, elm);

                for (var i = 0; i < elm.Count; i++)
                {
                    masters[elm[i]] = elmMasterIndex;
                }
            }

            #endregion

            for (var i = 0; i < n; i++)
            {
                if (masters[i] == i)
                {
                    masterCount++;
                }
            }


            var rMaster = new int[n];

            var cnt = 0;

            for (var i = 0; i < masters.Length; i++)
            {
                if (masters[i] == i)
                {
                    rMaster[i] = cnt++;
                }
                else
                {
                    rMaster[i] = -1;
                }
            }

            var buf = new CoordinateStorage <double>(6 * n, 6 * masterCount, 1);

            for (var i = 0; i < n; i++)
            {
                if (masters[i] == i)
                {
                    InsertPij(Matrix.Eye(6), rMaster[i], i, buf);
                }
                else
                {
                    var j   = masters[i];
                    var pij = GetPij(model, j, i);

                    InsertPij(pij, rMaster[j], i, buf);
                }
            }


            return(Converter.ToCompressedColumnStorage(buf));
        }
예제 #28
0
        public CompressedColumnStorage <double> GetInvertPermutationMatrix(Model model, LoadCase loadCase)
        {
            var n       = model.Nodes.Count;
            var masters = new int[n];

            for (var i = 0; i < n; i++)
            {
                masters[i] = i;
            }

            #region filling the masters

            foreach (var elm in model.RigidElements)
            {
                var apply = false;

                if (elm.UseForAllLoads)
                {
                    apply = true;
                }
                else
                {
                    foreach (var cse in elm.AppliedLoadCases)
                    {
                        if (cse.Equals(loadCase))
                        {
                            apply = true;
                            break;
                        }
                    }
                }


                if (apply)
                {
                    if (elm.Nodes.Count == 0)
                    {
                        continue;
                    }

                    var elmMasterIndex = elm.Nodes[0].Index;

                    for (var i = 0; i < elm.Nodes.Count; i++)
                    {
                        masters[elm.Nodes[i].Index] = elmMasterIndex;
                    }
                }
            }

            #endregion

            var masterCount = 0;

            for (var i = 0; i < n; i++)
            {
                if (masters[i] == i)
                {
                    masterCount++;
                }
            }

            var buf = new CoordinateStorage <double>(6 * n, masterCount, masterCount);

            for (var i = 0; i < n; i++)
            {
                if (masters[i] == i)
                {
                    InsertPij(Matrix.Eye(6), i, i, buf);
                }
            }


            return(Converter.ToCompressedColumnStorage(buf).Transpose());
        }
예제 #29
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UniformLoad1D"/> class.
 /// </summary>
 /// <param name="magnitude">The magnitude of load.</param>
 /// <param name="direction">The direction of load.</param>
 /// <param name="sys">The coordination system type.</param>
 /// <param name="cse">The load case.</param>
 public UniformLoad1D(double magnitude, LoadDirection direction, CoordinationSystem sys, LoadCase cse)
 {
     this.magnitude          = magnitude;
     this.coordinationSystem = sys;
     this.direction          = direction;
     this.Case = cse;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="LoadCase"/> struct. for ISerialable.
 /// </summary>
 /// <param name="info">The information.</param>
 /// <param name="context">The context.</param>
 private Settlement(SerializationInfo info, StreamingContext context)
 {
     loadCase     = (LoadCase)info.GetValue("caseName", typeof(LoadCase));
     displacement = (Displacement)info.GetValue("loadType", typeof(Displacement));
 }