public void DotProduct_WithOtherKeyedVector_IsComputed(double expected, params double[] otherVectorValues) { KeyedVector<int> otherVector = new KeyedVector<int>(keys, otherVectorValues); KeyedVector<int> SUT = new KeyedVector<int>(keys, 2, 3, 4); double result = SUT.DotProduct(otherVector); Assert.AreEqual(expected, result); }
public void CanAddMultipleDisplacements() { FiniteElementNode node1 = model.NodeFactory.Create(1); NodalDegreeOfFreedom ndof1 = new NodalDegreeOfFreedom(node, DegreeOfFreedom.X); NodalDegreeOfFreedom ndof2 = new NodalDegreeOfFreedom(node, DegreeOfFreedom.Y); NodalDegreeOfFreedom ndof3 = new NodalDegreeOfFreedom(node1, DegreeOfFreedom.Y); IList <NodalDegreeOfFreedom> identifiers = new List <NodalDegreeOfFreedom>(3); identifiers.Add(ndof1); identifiers.Add(ndof2); identifiers.Add(ndof3); KeyedVector <NodalDegreeOfFreedom> displacements = new KeyedVector <NodalDegreeOfFreedom>(identifiers); displacements[ndof1] = 10; displacements[ndof2] = 12; displacements[ndof3] = 13; SUT.AddMultipleDisplacements(displacements); Assert.AreEqual(10, SUT.GetDisplacement(node).X); Assert.AreEqual(12, SUT.GetDisplacement(node).Y); Assert.AreEqual(13, SUT.GetDisplacement(node1).Y); }
/// <summary> /// Calculates part of the problem for unknown displacements /// </summary> /// <returns>A vector of the displacements which were previously unknown, and have now been solved</returns> protected KeyedVector <NodalDegreeOfFreedom> CalculateUnknownDisplacements() { StiffnessMatrix knownForcesUnknownDisplacementStiffnesses = this.matrixBuilder.BuildKnownForcesUnknownDisplacementStiffnessMatrix(); // K11 //TODO calculating the determinant is computationally intensive. We should use another method of model verification to speed this up. double det = knownForcesUnknownDisplacementStiffnesses.Determinant(); Guard.AgainstInvalidState(() => { return(det.IsApproximatelyEqualTo(0.0)); }, "We are unable to solve this model as it is able to move as a rigid body without deforming in any way. Are you missing any constraints?\r\nMatrix of stiffnesses for known forces and unknown displacements:\r\n {0}", knownForcesUnknownDisplacementStiffnesses); KeyedVector <NodalDegreeOfFreedom> knownForces = this.model.KnownForceVector(); // Fk StiffnessMatrix knownForcesKnownDisplacementsStiffnesses = this.matrixBuilder.BuildKnownForcesKnownDisplacementStiffnessMatrix(); // K12 KeyedVector <NodalDegreeOfFreedom> knownDisplacements = this.model.KnownDisplacementVector(); // Uk // solve for unknown displacements // Uu = K11^-1 * (Fk + (K12 * Uk)) KeyedVector <NodalDegreeOfFreedom> forcesDueToExternallyAppliedDisplacements = knownForcesKnownDisplacementsStiffnesses.Multiply(knownDisplacements); // K12 * Uk KeyedVector <NodalDegreeOfFreedom> externallyAppliedForces = knownForces.Add(forcesDueToExternallyAppliedDisplacements); // Fk + (K12 * Uk) // K11^-1 * (Fk + (K12 * Uk)) KeyedVector <NodalDegreeOfFreedom> unknownDisplacements = this.Solve(knownForcesUnknownDisplacementStiffnesses, externallyAppliedForces); return(unknownDisplacements); }
private static void CollectorGather(Collector coll, KeyedVector <ResourceType> delta) { var cur = delta.Zeroed(); var location = coll.Location; foreach (var deposit in location.Terrain.Resources) { cur[deposit.Type] += deposit.Richness; } foreach (var feautre in location.MapFeautres) { foreach (var deposit in feautre.Resources) { cur[deposit.Type] += deposit.Richness; } } foreach (var res in cur) { if (res.Value < 0) { cur[res.Key] = 0; } } cur.Filter(coll.Type.Collected); delta.Add(cur); }
public void DotProduct_WithOtherKeyedVector_IsComputed(double expected, params double[] otherVectorValues) { KeyedVector <int> otherVector = new KeyedVector <int>(keys, otherVectorValues); KeyedVector <int> SUT = new KeyedVector <int>(keys, 2, 3, 4); double result = SUT.DotProduct(otherVector); Assert.AreEqual(expected, result); }
/// <summary> /// Puts the data into the results data structure. /// </summary> /// <param name="displacements">The calculated displacements. The index of the values in the vector matches the index of the displacement identifiers.</param> /// <param name="reactions">The calculated reactions. The index of the values in the vector matches the index of the reaction identifiers.</param> /// <returns>The results in a presentable data structure</returns> protected FiniteElementResults CreateResults(KeyedVector <NodalDegreeOfFreedom> displacements, KeyedVector <NodalDegreeOfFreedom> reactions) { Guard.AgainstNullArgument(displacements, "displacements"); Guard.AgainstNullArgument(reactions, "reactions"); FiniteElementResults results = new FiniteElementResults(this.model.ModelType); results.AddMultipleDisplacements(displacements); results.AddMultipleReactions(reactions); return(results); }
/// <summary> /// Solves the model containing the finite element problem /// </summary> /// <returns>The results of analysis</returns> public FiniteElementResults Solve() { this.ThrowIfNotAValidModel(); KeyedVector <NodalDegreeOfFreedom> displacements = this.CalculateUnknownDisplacements(); KeyedVector <NodalDegreeOfFreedom> reactions = this.CalculateUnknownReactions(displacements); reactions = this.CombineExternalForcesOnReactionNodesWithReactions(reactions); return(this.CreateResults(displacements, reactions)); }
public void GetKnownForceVector() { KeyedVector <NodalDegreeOfFreedom> result = SUT.KnownForceVector(); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); // can be accessed by a key NodalDegreeOfFreedom ndof1 = new NodalDegreeOfFreedom(node2, DegreeOfFreedom.X); Assert.AreEqual(20, result[ndof1]); }
public void Constructor_StoresKeysAndSetsAllValuesToZero() { KeyedVector<int> SUT = new KeyedVector<int>(keys); Assert.IsNotNull(SUT); IList<int> storedKeys = SUT.Keys; Assert.IsTrue(storedKeys.Contains(1)); Assert.IsTrue(storedKeys.Contains(4)); Assert.IsTrue(storedKeys.Contains(9)); Assert.AreEqual(0, SUT[1]); Assert.AreEqual(0, SUT[4]); Assert.AreEqual(0, SUT[9]); }
public void Constructor_WithInitialValueParameter_SetsAllValuesToTheInitialValue() { KeyedVector<int> SUT = new KeyedVector<int>(keys, 22); IList<int> storedKeys = SUT.Keys; Assert.IsTrue(storedKeys.Contains(1)); Assert.IsTrue(storedKeys.Contains(4)); Assert.IsTrue(storedKeys.Contains(9)); Assert.AreEqual(22, SUT[1]); Assert.AreEqual(22, SUT[4]); Assert.AreEqual(22, SUT[9]); }
public void GetKnownDisplacementVector() { KeyedVector <NodalDegreeOfFreedom> result = SUT.KnownDisplacementVector(); Assert.IsNotNull(result); Assert.AreEqual(2, result.Count); // can be accessed by a key NodalDegreeOfFreedom ndof1 = new NodalDegreeOfFreedom(node1, DegreeOfFreedom.X); NodalDegreeOfFreedom ndof2 = new NodalDegreeOfFreedom(node3, DegreeOfFreedom.X); Assert.AreEqual(0, result[ndof1]); Assert.AreEqual(0, result[ndof2]); }
public void Constructor_WithInitialValueParameter_SetsAllValuesToTheInitialValue() { KeyedVector <int> SUT = new KeyedVector <int>(keys, 22); IList <int> storedKeys = SUT.Keys; Assert.IsTrue(storedKeys.Contains(1)); Assert.IsTrue(storedKeys.Contains(4)); Assert.IsTrue(storedKeys.Contains(9)); Assert.AreEqual(22, SUT[1]); Assert.AreEqual(22, SUT[4]); Assert.AreEqual(22, SUT[9]); }
public Settlement(string name, Point position, int population, KeyedVector <ResourceType> resources) { Name = name; Position = position; Resources = resources; Population = population; Collectors = new(); Buildings = new(); Prices = Resources.Zeroed(); foreach (var resource in Resources) { Prices[resource.Key] = resource.Key.BasePrice; } }
public void Constructor_StoresKeysAndSetsAllValuesToZero() { KeyedVector <int> SUT = new KeyedVector <int>(keys); Assert.IsNotNull(SUT); IList <int> storedKeys = SUT.Keys; Assert.IsTrue(storedKeys.Contains(1)); Assert.IsTrue(storedKeys.Contains(4)); Assert.IsTrue(storedKeys.Contains(9)); Assert.AreEqual(0, SUT[1]); Assert.AreEqual(0, SUT[4]); Assert.AreEqual(0, SUT[9]); }
/// <summary> /// Calculates part of the stiffness equations for the unknown reactions. /// </summary> /// <param name="unknownDisplacements">A vector of the displacements which were previously unknown</param> /// <returns>A vector of the reactions which were previously unknown, and have now been solved</returns> protected KeyedVector <NodalDegreeOfFreedom> CalculateUnknownReactions(KeyedVector <NodalDegreeOfFreedom> unknownDisplacements) { Guard.AgainstNullArgument(unknownDisplacements, "unknownDisplacements"); // Fu = K21 * Uu + K22 * Uk StiffnessMatrix unknownForcesUnknownDisplacementStiffnesses = this.matrixBuilder.BuildUnknownForcesUnknownDisplacementStiffnessMatrix(); // K21 StiffnessMatrix unknownForcesKnownDisplacementsStiffnesses = this.matrixBuilder.BuildUnknownForcesKnownDisplacementStiffnessMatrix(); // K22 KeyedVector <NodalDegreeOfFreedom> knownDisplacements = this.model.KnownDisplacementVector(); // Uk KeyedVector <NodalDegreeOfFreedom> lhsStatement = unknownForcesUnknownDisplacementStiffnesses.Multiply(unknownDisplacements); // K21 * Uu KeyedVector <NodalDegreeOfFreedom> rhsStatement = unknownForcesKnownDisplacementsStiffnesses.Multiply(knownDisplacements); // K22 * Uk KeyedVector <NodalDegreeOfFreedom> unknownReactions = lhsStatement.Add(rhsStatement); return(unknownReactions); }
public void CanGetCombinedForcesOnMultipleNodalDegreeOfFreedom() { NodalDegreeOfFreedom nodeDof = new NodalDegreeOfFreedom(node, DegreeOfFreedom.X); IList <NodalDegreeOfFreedom> nodeDofList = new List <NodalDegreeOfFreedom>(1) { nodeDof }; KeyedVector <NodalDegreeOfFreedom> result = SUT.GetCombinedForcesFor(nodeDofList); Assert.AreEqual(1, result.Count); Assert.AreEqual(0, result[nodeDof]); SUT.ApplyForceToNode(exampleForce2, node); result = SUT.GetCombinedForcesFor(nodeDofList); Assert.AreEqual(1, result.Count); Assert.AreEqual(2, result[nodeDof]); }
public void DecayResources(int turn, Settlement settlement) { KeyedVector <ResourceType>?delta = null; if (_log != null) { delta = settlement.Resources.Zeroed(); } foreach (var res in settlement.Resources) { if (delta != null) { delta[res.Key] = res.Key.DecayRate * res.Value; } settlement.Resources[res.Key] = (1 - res.Key.DecayRate) * res.Value; } if ((_log != null) && (delta != null)) { _log.AddEntry(new LogEntryDecay(turn, settlement, delta)); } }
public GeometricVector(KeyedVector <DegreeOfFreedom> vectorToClone) : base(vectorToClone) { Guard.AgainstBadArgument( "vectorToClone", () => { return(!vectorToClone.Keys.Contains(DegreeOfFreedom.X)); }, "DegreeOfFreedom.X was expected as a key"); Guard.AgainstBadArgument( "vectorToClone", () => { return(!vectorToClone.Keys.Contains(DegreeOfFreedom.Y)); }, "DegreeOfFreedom.Y was expected as a key"); Guard.AgainstBadArgument( "vectorToClone", () => { return(!vectorToClone.Keys.Contains(DegreeOfFreedom.Z)); }, "DegreeOfFreedom.Z was expected as a key"); }
public void CanAddMultipleDisplacements() { FiniteElementNode node1 = model.NodeFactory.Create(1); NodalDegreeOfFreedom ndof1 = new NodalDegreeOfFreedom(node, DegreeOfFreedom.X); NodalDegreeOfFreedom ndof2 = new NodalDegreeOfFreedom(node, DegreeOfFreedom.Y); NodalDegreeOfFreedom ndof3 = new NodalDegreeOfFreedom(node1, DegreeOfFreedom.Y); IList<NodalDegreeOfFreedom> identifiers = new List<NodalDegreeOfFreedom>(3); identifiers.Add(ndof1); identifiers.Add(ndof2); identifiers.Add(ndof3); KeyedVector<NodalDegreeOfFreedom> displacements = new KeyedVector<NodalDegreeOfFreedom>(identifiers); displacements[ndof1] = 10; displacements[ndof2] = 12; displacements[ndof3] = 13; SUT.AddMultipleDisplacements(displacements); Assert.AreEqual(10, SUT.GetDisplacement(node).X); Assert.AreEqual(12, SUT.GetDisplacement(node).Y); Assert.AreEqual(13, SUT.GetDisplacement(node1).Y); }
/// <summary> /// /// </summary> /// <param name="stiffnessMatrix"></param> /// <param name="forceVector"></param> /// <returns></returns> protected override KeyedVector<NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector<NodalDegreeOfFreedom> forceVector) { Svd<NodalDegreeOfFreedom, NodalDegreeOfFreedom> svd = new Svd<NodalDegreeOfFreedom, NodalDegreeOfFreedom>(stiffnessMatrix, true); return svd.Solve(forceVector); }
public BuildingType(string id, KeyedVector <ResourceType> input, KeyedVector <ResourceType> output) { Id = id; Input = input; Output = output; }
public CartesianPoint(KeyedVector <DegreeOfFreedom> coords) : base(coords) { // empty }
/// <summary> /// Adds multiple reaction to this set of results /// </summary> /// <param name="reactions">The value of the reactions. The order of this vector matches the order of the identifiers in the corresponding parameter.</param> public void AddMultipleReactions(KeyedVector<NodalDegreeOfFreedom> react) { Guard.AgainstNullArgument(reactions, "reactions"); foreach (KeyValuePair<NodalDegreeOfFreedom, double> kvp in react) { this.AddReaction(kvp.Key, kvp.Value); } }
/// <summary> /// Adds multiple displacements to the set of results /// </summary> /// <param name="displacements">The value of the displacements. The order of this vector matches the order of the identifiers in the corresponding parameter</param> public void AddMultipleDisplacements(KeyedVector<NodalDegreeOfFreedom> disp) { Guard.AgainstNullArgument(disp, "displacements"); foreach (KeyValuePair<NodalDegreeOfFreedom, double> kvp in disp) { this.AddDisplacement(kvp.Key, kvp.Value); } }
/// <summary> /// Solves AX=B for X. /// </summary> /// <param name="stiffnessMatrix">The stiffness matrix</param> /// <param name="forceVector">The forces</param> /// <returns></returns> protected abstract KeyedVector<NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector<NodalDegreeOfFreedom> forceVector);
/// <summary> /// The user may have placed reactions directly on to fixed supports. /// These are ignored during the calculation, but the correct answer for the total reaction must include them /// </summary> /// <param name="reactions">The calculated values of the reactions</param> /// <returns>The calculated values of the reactions with additional external forces added where applicable.</returns> protected KeyedVector <NodalDegreeOfFreedom> CombineExternalForcesOnReactionNodesWithReactions(KeyedVector <NodalDegreeOfFreedom> reactions) { KeyedVector <NodalDegreeOfFreedom> externalForcesOnReactionNodes = this.model.GetCombinedForcesFor(reactions.Keys); return(reactions.Add(externalForcesOnReactionNodes)); }
/// <summary> /// Puts the data into the results data structure. /// </summary> /// <param name="displacements">The calculated displacements. The index of the values in the vector matches the index of the displacement identifiers.</param> /// <param name="reactions">The calculated reactions. The index of the values in the vector matches the index of the reaction identifiers.</param> /// <returns>The results in a presentable data structure</returns> protected FiniteElementResults CreateResults(KeyedVector<NodalDegreeOfFreedom> displacements, KeyedVector<NodalDegreeOfFreedom> reactions) { Guard.AgainstNullArgument(displacements, "displacements"); Guard.AgainstNullArgument(reactions, "reactions"); FiniteElementResults results = new FiniteElementResults(this.model.ModelType); results.AddMultipleDisplacements(displacements); results.AddMultipleReactions(reactions); return results; }
/// <summary> /// Solves AX=B for X. /// </summary> /// <param name="stiffnessMatrix">The stiffness matrix</param> /// <param name="forceVector">The forces</param> /// <returns></returns> protected abstract KeyedVector <NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector <NodalDegreeOfFreedom> forceVector);
public LogEntryProduce(int turn, Settlement settlement, KeyedVector <ResourceType> delta) { _turn = turn; _settlement = settlement; _delta = delta; }
private static void BuildingGetTotalConsumption(Building build, KeyedVector <ResourceType> delta) { delta.Add(build.Type.Input); delta.Sub(build.Type.Output); }
protected override KeyedVector<NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector<NodalDegreeOfFreedom> forceVector) { KeyedSquareMatrix<NodalDegreeOfFreedom> inverse = stiffnessMatrix.Inverse(); KeyedVector<NodalDegreeOfFreedom> solution = inverse.Multiply(forceVector); return solution; }
/// <summary> /// Calculates part of the stiffness equations for the unknown reactions. /// </summary> /// <param name="unknownDisplacements">A vector of the displacements which were previously unknown</param> /// <returns>A vector of the reactions which were previously unknown, and have now been solved</returns> protected KeyedVector<NodalDegreeOfFreedom> CalculateUnknownReactions(KeyedVector<NodalDegreeOfFreedom> unknownDisplacements) { Guard.AgainstNullArgument(unknownDisplacements, "unknownDisplacements"); // Fu = K21 * Uu + K22 * Uk StiffnessMatrix unknownForcesUnknownDisplacementStiffnesses = this.matrixBuilder.BuildUnknownForcesUnknownDisplacementStiffnessMatrix(); // K21 StiffnessMatrix unknownForcesKnownDisplacementsStiffnesses = this.matrixBuilder.BuildUnknownForcesKnownDisplacementStiffnessMatrix(); // K22 KeyedVector<NodalDegreeOfFreedom> knownDisplacements = this.model.KnownDisplacementVector(); // Uk KeyedVector<NodalDegreeOfFreedom> lhsStatement = unknownForcesUnknownDisplacementStiffnesses.Multiply(unknownDisplacements); // K21 * Uu KeyedVector<NodalDegreeOfFreedom> rhsStatement = unknownForcesKnownDisplacementsStiffnesses.Multiply(knownDisplacements); // K22 * Uk KeyedVector<NodalDegreeOfFreedom> unknownReactions = lhsStatement.Add(rhsStatement); return unknownReactions; }
public KeyedVector <TColumnKey> Solve(KeyedVector <TRowKey> b) { Vector <double> solution = this._underlyingSvd.Solve(b.ToVector()); return(new KeyedVector <TColumnKey>(data.ColumnKeys, solution)); }
/// <summary> /// The user may have placed reactions directly on to fixed supports. /// These are ignored during the calculation, but the correct answer for the total reaction must include them /// </summary> /// <param name="reactions">The calculated values of the reactions</param> /// <returns>The calculated values of the reactions with additional external forces added where applicable.</returns> protected KeyedVector<NodalDegreeOfFreedom> CombineExternalForcesOnReactionNodesWithReactions(KeyedVector<NodalDegreeOfFreedom> reactions) { KeyedVector<NodalDegreeOfFreedom> externalForcesOnReactionNodes = this.model.GetCombinedForcesFor(reactions.Keys); return reactions.Add(externalForcesOnReactionNodes); }