public void SpringAt60DegreesInXYPlane()
{
FiniteElementModel model = new FiniteElementModel(ModelType.Truss2D); // we will create and analyze a 2D truss system
FiniteElementNode node1 = model.NodeFactory.CreateFor2DTruss(0, 0); // create a node at the origin
model.ConstrainNode(node1, DegreeOfFreedom.X); // constrain this node from moving in the X axis
model.ConstrainNode(node1, DegreeOfFreedom.Z); // also constrain it from moving in the Y axis
FiniteElementNode node2 = model.NodeFactory.CreateFor2DTruss(1, 1.73205); // create a second node at a distance 1 metre along the X axis and 1.73 metres along the Y axis (giving an angle of 60 degrees from x-axis).
model.ConstrainNode(node2, DegreeOfFreedom.X);
LinearConstantSpring spring = model.ElementFactory.CreateLinearConstantSpring(node1, node2, 1000); // create a spring between the first two nodes of a stiffness of 1000 Newtons per metre
ForceVector force = model.ForceFactory.CreateForTruss(0, 10); // Create a force of with components of 10 Newtons along the y-axis.
model.ApplyForceToNode(force, node2); // Apply that force to the second node
IFiniteElementSolver solver = new MatrixInversionLinearSolver(model); // Create a new instance of the solver class and pass it the model to solve
FiniteElementResults results = solver.Solve(); // ask the solver to solve the model and return results
DisplacementVector displacementAtNode2 = results.GetDisplacement(node2); // get the displacement at the second node
Assert.AreEqual(0, displacementAtNode2.X); // Check that there is no displacement in the x-axis
Assert.AreEqual(0.013333, displacementAtNode2.Z, 0.001); // and 0.01333 metres (13 millimetres) along the Y axis.
ReactionVector reactionAtNode1 = results.GetReaction(node1); //get the reaction at the first node
Assert.AreEqual(-5.774, reactionAtNode1.X, 0.001); // Check that we have calculated a reaction of 10/SQRT(3) Newtons in the X axis.
Assert.AreEqual(-10, reactionAtNode1.Z, 0.001); // and a reaction of -10 Newtons in the Y axis.
}
public void SpringInXAxis()
{
FiniteElementModel model = new FiniteElementModel(ModelType.Truss2D); // we will create and analyze a 1D spring in the vertical
FiniteElementNode node1 = model.NodeFactory.CreateFor2DTruss(0, 0); // create a node at the origin
model.ConstrainNode(node1, DegreeOfFreedom.X); // constrain this node from moving in the X axis
model.ConstrainNode(node1, DegreeOfFreedom.Z); // also constrain it from moving in the Y axis
FiniteElementNode node2 = model.NodeFactory.CreateFor2DTruss(1, 0); // create a second node at a distance 1 metre along the X axis.
model.ConstrainNode(node2, DegreeOfFreedom.Z); // fix this node from moving along the Y-axis. It is still free to move along the X-axis however.
LinearConstantSpring spring = model.ElementFactory.CreateLinearConstantSpring(node1, node2, 1000); // create a spring between the two nodes of a stiffness of 1000 Newtons per metre
ForceVector force = model.ForceFactory.CreateForTruss(10, 0); // Create a force of 10 Newtons along the x-axis.
model.ApplyForceToNode(force, node2); // Apply that force to the second node
IFiniteElementSolver solver = new MatrixInversionLinearSolver(model); // Create a new instance of the solver class and pass it the model to solve
FiniteElementResults results = solver.Solve(); // ask the solver to solve the model and return results
DisplacementVector displacementAtNode2 = results.GetDisplacement(node2); // get the displacement at the second node
Assert.AreEqual(0.01, displacementAtNode2.X); // check that we calculated 0.010 metres (10 millimetres) along the Y axis.
ReactionVector reactionAtNode1 = results.GetReaction(node1); //get the reaction at the first node
Assert.AreEqual(-10, reactionAtNode1.X); // Check that we have calculated a reaction of -10 Newtons in the X axis.
Assert.AreEqual(0, reactionAtNode1.Z); // and a reaction of 0 Newtons in the Y axis.
}
public void SetUp()
{
nodeFactory = new NodeFactory(ModelType.Truss1D);
start = nodeFactory.Create(0);
end = nodeFactory.Create(1);
elementFactory = new ElementFactory(ModelType.Truss1D);
SUT = elementFactory.CreateLinearConstantSpring(start, end, 2);
}
public void ElementsCanBeCreated()
{
LinearConstantSpring result = SUT.CreateLinearConstantSpring(node1, node2, 1);
Assert.IsNotNull(result);
Assert.AreEqual(node1, result.StartNode);
Assert.AreEqual(node2, result.EndNode);
}
public void SetUp()
{
this.nodeFactory = new NodeFactory(ModelType.Truss1D);
this.start = nodeFactory.Create(0);
this.end = nodeFactory.Create(1);
this.elementFactory = new ElementFactory(ModelType.Truss1D);
this.spring = elementFactory.CreateLinearConstantSpring(start, end, 2);
this.SUT = new LinearTrussStiffnessMatrixBuilder(spring);
}
public void SetUp()
{
model = null;
node1 = null;
node2 = null;
spring1 = null;
force1 = null;
SUT = null;
}
public void SetUp()
{
this.nodeFactory = new NodeFactory(ModelType.Truss1D);
this.start = nodeFactory.Create(0);
this.end = nodeFactory.Create(1);
this.elementFactory = new ElementFactory(ModelType.Truss1D);
this.spring = elementFactory.CreateLinearConstantSpring(start, end, 2);
this.SUT = new LinearTrussStiffnessMatrixBuilder(spring);
}
protected void CreateAndStore3DSpringFromOriginTo(double x, double y, double z)
{
nodeFactory = new NodeFactory(ModelType.Truss3D);
start = nodeFactory.Create(0, 0, 0);
end = nodeFactory.Create(x, y, z);
elementFactory = new ElementFactory(ModelType.Truss3D);
this.spring = elementFactory.CreateLinearConstantSpring(start, end, 1);
this.SUT = new LinearTrussStiffnessMatrixBuilder(this.spring);
}
protected void CreateAndStore3DSpringFromOriginTo(double x, double y, double z)
{
nodeFactory = new NodeFactory(ModelType.Truss3D);
start = nodeFactory.Create(0, 0, 0);
end = nodeFactory.Create(x, y, z);
elementFactory = new ElementFactory(ModelType.Truss3D);
this.spring = elementFactory.CreateLinearConstantSpring(start, end, 1);
this.SUT = new LinearTrussStiffnessMatrixBuilder(this.spring);
}
protected void CreateAndStore2DSpringFromOriginTo(double x, double z)
{
this.nodeFactory = new NodeFactory(ModelType.Truss2D);
this.start = nodeFactory.CreateFor2DTruss(0, 0);
this.end = nodeFactory.CreateFor2DTruss(x, z);
this.elementFactory = new ElementFactory(ModelType.Truss2D);
this.spring = elementFactory.CreateLinearConstantSpring(this.start, this.end, 1);
this.SUT = new LinearTrussStiffnessMatrixBuilder(this.spring);
}
protected void CreateAndStore2DSpringFromOriginTo(double x, double z)
{
this.nodeFactory = new NodeFactory(ModelType.Truss2D);
this.start = nodeFactory.CreateFor2DTruss(0, 0);
this.end = nodeFactory.CreateFor2DTruss(x, z);
this.elementFactory = new ElementFactory(ModelType.Truss2D);
this.spring = elementFactory.CreateLinearConstantSpring(this.start, this.end, 1);
this.SUT = new LinearTrussStiffnessMatrixBuilder(this.spring);
}
public void Setup()
{
nodeFactory = new NodeFactory(ModelType.Truss2D);
node1 = nodeFactory.CreateFor2DTruss(0, 0);
node2 = nodeFactory.CreateFor2DTruss(0, 1);
node3 = nodeFactory.CreateFor2DTruss(0, 2);
SUT = new ElementRepository();
elementFactory = new ElementFactory(ModelType.Truss2D, SUT);
spring1 = elementFactory.CreateLinearConstantSpring(node1, node2, 1);
spring2 = elementFactory.CreateLinearConstantSpring(node2, node3, 2);
}
public void HashCode_changes_with_stiffness_value()
{
int SUTOriginalHash = SUT.GetHashCode();
LinearConstantSpring equal = elementFactory.CreateLinearConstantSpring(start, end, 2);
Assert.AreEqual(SUTOriginalHash, equal.GetHashCode());
LinearConstantSpring unequal = elementFactory.CreateLinearConstantSpring(start, end, 4);
Assert.AreNotEqual(SUTOriginalHash, unequal.GetHashCode());
}
public void Can_determine_if_equal()
{
Assert.IsTrue(SUT.Equals(SUT));
LinearConstantSpring equal = elementFactory.CreateLinearConstantSpring(start, end, 2);
Assert.IsTrue(SUT.Equals(equal));
LinearConstantSpring notEqual = elementFactory.CreateLinearConstantSpring(start, end, 4);
Assert.IsFalse(SUT.Equals(notEqual));
}
public void SetUp()
{
model = new FiniteElementModel(ModelType.Truss1D);
node1 = model.NodeFactory.Create(0);
node2 = model.NodeFactory.Create(1);
spring1 = model.ElementFactory.CreateLinearConstantSpring(node1, node2, 4);
model.ConstrainNode(node1, DegreeOfFreedom.X);
force1 = model.ForceFactory.Create(20);
model.ApplyForceToNode(force1, node2);
SUT = new LinearSolverSVD(model);
}
public void SetUp()
{
model = new FiniteElementModel(ModelType.Truss1D);
node1 = model.NodeFactory.Create(0);
node2 = model.NodeFactory.Create(1);
spring1 = model.ElementFactory.CreateLinearConstantSpring(node1, node2, 4);
model.ConstrainNode(node1, DegreeOfFreedom.X);
force1 = model.ForceFactory.Create(20);
model.ApplyForceToNode(force1, node2);
SUT = new LinearSolverSVD(model);
}
public void Setup()
{
SUT = new FiniteElementModel(ModelType.Truss1D);
node1 = SUT.NodeFactory.Create(0);
node2 = SUT.NodeFactory.Create(1);
node3 = SUT.NodeFactory.Create(2);
spring1 = SUT.ElementFactory.CreateLinearConstantSpring(node1, node2, 3);
spring2 = SUT.ElementFactory.CreateLinearConstantSpring(node2, node3, 2);
SUT.ConstrainNode(node1, DegreeOfFreedom.X);
SUT.ConstrainNode(node3, DegreeOfFreedom.X);
force1 = SUT.ForceFactory.Create(20);
SUT.ApplyForceToNode(force1, node2);
}
private void Create2DSingleSpringModelAroundOrigin(double x, double z)
{
model = new FiniteElementModel(ModelType.Truss2D);
node1 = model.NodeFactory.CreateFor2DTruss(0, 0);
node2 = model.NodeFactory.CreateFor2DTruss(x, z);
spring1 = model.ElementFactory.CreateLinearConstantSpring(node1, node2, 1000);
model.ConstrainNode(node1, DegreeOfFreedom.X);
model.ConstrainNode(node1, DegreeOfFreedom.Z);
model.ConstrainNode(node2, DegreeOfFreedom.X);
force1 = model.ForceFactory.CreateForTruss(0, -10);
model.ApplyForceToNode(force1, node2);
SUT = new LinearSolverSVD(model);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private double CalculateStiffnessConstant()
{
try
{
LinearConstantSpring spring = this.Element as LinearConstantSpring;
if (spring != null)
{
return(spring.SpringConstant);
}
}
catch (InvalidCastException)
{
// do nothing
}
LinearTruss truss = this.Element as LinearTruss;
return(truss.Material.YoungsModulus * truss.CrossSection.Area / this.Element.OriginalLength);
}
/// <summary>
/// Creates a new <see cref="Spring" /> finite element.
/// </summary>
/// <param name="node1">The node at the start of the spring</param>
/// <param name="node2">The node at the end of the spring</param>
/// <param name="springConstant">The constant value of stiffness of the spring.</param>
/// <returns>The newly created Spring element</returns>
public LinearConstantSpring CreateLinearConstantSpring(IFiniteElementNode node1, IFiniteElementNode node2, double springConstant)
{
Guard.AgainstInvalidState(() => { return !LinearConstantSpring.IsASupportedModelType(this.ModelType); },
"LinearConstantSpring are not available in a model of type {0}",
this.ModelType);
LinearConstantSpring newSpring = new LinearConstantSpring(node1, node2, springConstant);
if (this.repository != null)
{
this.repository.Add(newSpring);
}
return newSpring;
}
public void SetUp()
{
model = null;
node1 = null;
node2 = null;
spring1 = null;
force1 = null;
SUT = null;
}
public void Setup()
{
SUT = new FiniteElementModel(ModelType.Truss1D);
node1 = SUT.NodeFactory.Create(0);
node2 = SUT.NodeFactory.Create(1);
node3 = SUT.NodeFactory.Create(2);
spring1 = SUT.ElementFactory.CreateLinearConstantSpring(node1, node2, 3);
spring2 = SUT.ElementFactory.CreateLinearConstantSpring(node2, node3, 2);
SUT.ConstrainNode(node1, DegreeOfFreedom.X);
SUT.ConstrainNode(node3, DegreeOfFreedom.X);
force1 = SUT.ForceFactory.Create(20);
SUT.ApplyForceToNode(force1, node2);
}
private void Create2DSingleSpringModelAroundOrigin(double x, double z)
{
model = new FiniteElementModel(ModelType.Truss2D);
node1 = model.NodeFactory.CreateFor2DTruss(0, 0);
node2 = model.NodeFactory.CreateFor2DTruss(x, z);
spring1 = model.ElementFactory.CreateLinearConstantSpring(node1, node2, 1000);
model.ConstrainNode(node1, DegreeOfFreedom.X);
model.ConstrainNode(node1, DegreeOfFreedom.Z);
model.ConstrainNode(node2, DegreeOfFreedom.X);
force1 = model.ForceFactory.CreateForTruss(0, -10);
model.ApplyForceToNode(force1, node2);
SUT = new LinearSolverSVD(model);
}
public void Setup()
{
nodeFactory = new NodeFactory(ModelType.Truss2D);
node1 = nodeFactory.CreateFor2DTruss(0, 0);
node2 = nodeFactory.CreateFor2DTruss(0, 1);
node3 = nodeFactory.CreateFor2DTruss(0, 2);
SUT = new ElementRepository();
elementFactory = new ElementFactory(ModelType.Truss2D, SUT);
spring1 = elementFactory.CreateLinearConstantSpring(node1, node2, 1);
spring2 = elementFactory.CreateLinearConstantSpring(node2, node3, 2);
}
public void SetUp()
{
nodeFactory = new NodeFactory(ModelType.Truss1D);
start = nodeFactory.Create(0);
end = nodeFactory.Create(1);
elementFactory = new ElementFactory(ModelType.Truss1D);
SUT = elementFactory.CreateLinearConstantSpring(start, end, 2);
}
