public void WillCheckForInsufficientNumberOfElements()
{
model = new FiniteElementModel(ModelType.Truss1D);
node1 = model.NodeFactory.Create(0);
node2 = model.NodeFactory.Create(1);
SUT = new MatrixInversionLinearSolver(model);
SUT.Solve();
}
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);
}
/// <summary>
/// Determines whether this node matches another node
/// </summary>
/// <param name="other">the other node to compare for equality</param>
/// <returns>true if the nodes are equal; otherwise, false</returns>
public bool Equals(FiniteElementNode other)
{
if (other == null)
{
return(false);
}
return(object.Equals(this.X, other.X) && object.Equals(this.Y, other.Y) && object.Equals(this.Z, other.Z));
}
public void SetUp()
{
nodeFactory = new NodeFactory(ModelType.Truss1D);
start = nodeFactory.Create(0);
end = nodeFactory.Create(1);
elementFactory = new ElementFactory(ModelType.Truss1D);
material = new GenericElasticMaterial(0, 0.1, 0, 0);
section = new SolidRectangle(0.1, 1);
SUT = elementFactory.CreateLinearTruss(start, end, material, section);
}
public void SetUp()
{
ModelType modelType = ModelType.Beam1D;
nodeFactory = new NodeFactory(modelType);
start = nodeFactory.Create(0);
end = nodeFactory.Create(1);
elementFactory = new ElementFactory(modelType);
material = new GenericElasticMaterial(0, 0.1, 0, 0);
section = new SolidRectangle(0.1, 1);
SUT = elementFactory.CreateLinear3DBeam(start, end, material, section);
}
/// <summary>
/// Create a new node in a 1D model type
/// </summary>
/// <param name="coordinateAlongGlobalXAxis">The location of the node along the global x-axis</param>
/// <returns>The newly created node</returns>
public FiniteElementNode Create(double coordinateAlongGlobalXAxis)
{
Guard.AgainstInvalidState(() => { return this.modelType.GetDimensions() != GeometryDimensionality.OneDimension; },
"Can only create a Node with an x-coordinate when a 1D system is in use");
FiniteElementNode newNode = new FiniteElementNode(coordinateAlongGlobalXAxis);
if (this.repo != null)
{
this.repo.Add(newNode);
}
return newNode;
}
/// <summary>
/// Create a new node in a 1D model type
/// </summary>
/// <param name="coordinateAlongGlobalXAxis">The location of the node along the global x-axis</param>
/// <returns>The newly created node</returns>
public FiniteElementNode Create(double coordinateAlongGlobalXAxis)
{
Guard.AgainstInvalidState(() => { return(this.modelType.GetDimensions() != GeometryDimensionality.OneDimension); },
"Can only create a Node with an x-coordinate when a 1D system is in use");
FiniteElementNode newNode = new FiniteElementNode(coordinateAlongGlobalXAxis);
if (this.repo != null)
{
this.repo.Add(newNode);
}
return(newNode);
}
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);
}
/// <summary>
///
/// </summary>
/// <param name="coordinateAlongGlobalXAxis"></param>
/// <param name="coordinateAlongGlobalZAxis"></param>
/// <returns></returns>
public FiniteElementNode CreateFor2DTruss(double coordinateAlongGlobalXAxis, double coordinateAlongGlobalZAxis)
{
Guard.AgainstInvalidState(() => { return(this.modelType.GetDimensions() != GeometryDimensionality.TwoDimension); },
"Can only create a Node with an x and z coordinate when a 2D system is in use");
Guard.AgainstInvalidState(() => { return(!this.modelType.IsAllowedDegreeOfFreedomForGeometry(DegreeOfFreedom.Z)); },
"Cannot define geometry in the Z-direction for model type of {0}. Use the Create method instead.",
this.modelType);
FiniteElementNode newNode = new FiniteElementNode(coordinateAlongGlobalXAxis, 0, coordinateAlongGlobalZAxis);
if (this.repo != null)
{
this.repo.Add(newNode);
}
return(newNode);
}
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.SUT = elementFactory.CreateLinearConstantSpring(this.start, this.end, 1);
}
/// <summary>
/// Determines whether this node is equal to an object
/// </summary>
/// <param name="obj">the object to compare with this node for equality</param>
/// <returns>true if the object is equal to this node; otherwise, false</returns>
public override bool Equals(object obj)
{
FiniteElementNode other = obj as FiniteElementNode;
return(this.Equals(other));
}
/// <summary>
/// Create a new node in a 2D model type
/// </summary>
/// <param name="coordinateAlongGlobalXAxis">The location of the node along the global x-axis</param>
/// <param name="coordinateAlongGlobalYAxis">The location of the node along the global y-axis</param>
/// <returns>The newly created node</returns>
public FiniteElementNode Create(double coordinateAlongGlobalXAxis, double coordinateAlongGlobalYAxis)
{
Guard.AgainstInvalidState(() => { return this.modelType.GetDimensions() != GeometryDimensionality.TwoDimension; },
"Can only create a Node with an x and y coordinate when a 2D system is in use");
Guard.AgainstInvalidState(() => { return !this.modelType.IsAllowedDegreeOfFreedomForGeometry(DegreeOfFreedom.Y); },
"Cannot define geometry in the Y-direction for model type of {0}. Use the CreateForTruss method instead.",
this.modelType);
FiniteElementNode newNode = new FiniteElementNode(coordinateAlongGlobalXAxis, coordinateAlongGlobalYAxis);
if (this.repo != null)
{
this.repo.Add(newNode);
}
return newNode;
}
public void SetUp()
{
model = null;
node1 = null;
node2 = null;
spring1 = null;
force1 = null;
SUT = null;
}
/// <summary>
/// Determines whether this node matches another node
/// </summary>
/// <param name="other">the other node to compare for equality</param>
/// <returns>true if the nodes are equal; otherwise, false</returns>
public bool Equals(FiniteElementNode other)
{
if (other == null)
{
return false;
}
return object.Equals(this.X, other.X) && object.Equals(this.Y, other.Y) && object.Equals(this.Z, other.Z);
}
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);
}
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);
}
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 NodesCanHaveAConstraint()
{
SUT = new NodeRepository(ModelType.Full3D);
nodeFactory = new NodeFactory(ModelType.Full3D, SUT);
node1 = nodeFactory.Create(0, 0, 0);
Assert.IsFalse(SUT.IsConstrained(node1, DegreeOfFreedom.X));
Assert.IsFalse(SUT.IsConstrained(node1, DegreeOfFreedom.Y));
Assert.IsFalse(SUT.IsConstrained(node1, DegreeOfFreedom.Z));
Assert.IsFalse(SUT.IsConstrained(node1, DegreeOfFreedom.XX));
Assert.IsFalse(SUT.IsConstrained(node1, DegreeOfFreedom.YY));
Assert.IsFalse(SUT.IsConstrained(node1, DegreeOfFreedom.ZZ));
SUT.ConstrainNode(node1, DegreeOfFreedom.X);
Assert.IsTrue(SUT.IsConstrained(node1, DegreeOfFreedom.X));
Assert.IsFalse(SUT.IsConstrained(node1, DegreeOfFreedom.Y));
SUT.ConstrainNode(node1, DegreeOfFreedom.Y);
Assert.IsTrue(SUT.IsConstrained(node1, DegreeOfFreedom.X));
Assert.IsTrue(SUT.IsConstrained(node1, DegreeOfFreedom.Y));
SUT.ConstrainNode(node1, DegreeOfFreedom.Z);
Assert.IsTrue(SUT.IsConstrained(node1, DegreeOfFreedom.Z));
SUT.ConstrainNode(node1, DegreeOfFreedom.XX);
Assert.IsTrue(SUT.IsConstrained(node1, DegreeOfFreedom.XX));
SUT.ConstrainNode(node1, DegreeOfFreedom.YY);
Assert.IsTrue(SUT.IsConstrained(node1, DegreeOfFreedom.YY));
SUT.ConstrainNode(node1, DegreeOfFreedom.ZZ);
Assert.IsTrue(SUT.IsConstrained(node1, DegreeOfFreedom.ZZ));
}
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.SUT = elementFactory.CreateLinearConstantSpring(start, end, 1);
}
public void Setup()
{
SUT = new NodeRepository(ModelType.Truss1D);
nodeFactory = new NodeFactory(ModelType.Truss1D, SUT);
node1 = nodeFactory.Create(0);
node2 = nodeFactory.Create(1);
node3 = nodeFactory.Create(2);
}
public void Setup()
{
SUT = new ForceRepository();
forceFactory = new ForceFactory(ModelType.Truss1D, SUT);
exampleForce1 = forceFactory.Create(1);
exampleForce2 = forceFactory.Create(2);
nodeFactory = new NodeFactory(ModelType.Truss1D);
node = nodeFactory.Create(0);
}
