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);
}
