/// <summary>
/// Gather member which provide continuity with the specified member
/// </summary>
/// <param name="Member"></param>
/// <returns></returns>
public static IEnumerable<Member> GatherParallelMembers(Member Member, Node LastNode = null, bool MoveDownstream = false)
{
Node currentNode;
Member nextMember;
IEnumerable<Member> connectedParallelMembers;
HashSet<Member> parallelMembers;
parallelMembers = new HashSet<Member>();
if (MoveDownstream)
parallelMembers.Add(Member);
// Determine which will be the next node
currentNode = MemberHelpers.DetermineNextNode(Member, LastNode, MoveDownstream);
connectedParallelMembers = currentNode.ConnectedBeams.Select(b => b.Member).Where(m => m != null && m != Member && m.DetermineMemberRelation(Member) == MEMBERRELATION.PARALLEL);
if (connectedParallelMembers.Any())
{
nextMember = connectedParallelMembers.First();
parallelMembers.UnionWith(GatherParallelMembers(nextMember, currentNode, MoveDownstream));
}
else
{
if (!MoveDownstream)
parallelMembers.UnionWith(GatherParallelMembers(Member, currentNode, true));
}
return parallelMembers;
}
/// <summary>
/// Determine the next node to go to on the specified member, depending on which the last node was
/// </summary>
/// <param name="Beam">The member to inspect</param>
/// <param name="LastNode">The previously visited node</param>
/// <param name="MoveDownstream">The direction in which to move along the member</param>
/// <returns>The next node</returns>
public static Node DetermineNextNode(Member Member, Node LastNode = null, bool MoveDownstream = false)
{
Node currentNode;
// Determine which will be the next node depending on the beam orientation and direction of travel
if (MoveDownstream)
{
currentNode = Member.EndNode;
if (LastNode != null && LastNode == Member.EndNode)
currentNode = Member.StartNode;
}
else
{
currentNode = Member.StartNode;
if (LastNode != null && LastNode == Member.StartNode)
currentNode = Member.EndNode;
}
return currentNode;
}
public MemberGeneratorStatusUpdateEventArgs(string Status = "", double CompletionRate = 0, Member CurrentMember = null)
{
this.Status = Status;
this.CompletionRate = CompletionRate;
this.CurrentMember = CurrentMember;
}
public bool Equals(Member m)
{
if ((object)m == null)
return false;
return this.ID == m.ID;
}
public MEMBERRELATION DetermineMemberRelation(Member Member)
{
switch (this.Beams.First().DetermineBeamRelationship(Member.Beams.First()))
{
case BEAMRELATION.PARALLEL:
return MEMBERRELATION.PARALLEL;
case BEAMRELATION.ORTHOGONAL:
return MEMBERRELATION.ORTHOGONAL;
case BEAMRELATION.OTHER:
default:
return MEMBERRELATION.OTHER;
}
}
/// <summary>
/// Gather all members within the specified chain which connect between two primary members, centred on the specified member
/// </summary>
/// <param name="Member">The member on which to base the chain</param>
/// <param name="ParallelMembers">All the members which provide continuity with the specified member</param>
/// <param name="LastNode">The last visited node (leave blank at the start)</param>
/// <param name="MoveDownstream">The direction in which to move next (leave blank at start)</param>
/// <returns>A list of parallel members spanning between two primary members</returns>
private IEnumerable<Member> GatherMembersBetweenPrimaryMembers(Member Member, IEnumerable<Member> ParallelMembers, Node LastNode = null, bool MoveDownstream = false)
{
bool endHere;
Node currentNode;
Member nextMember;
HashSet<Member> members;
members = new HashSet<Member>() { Member };
// Determine the next node depending on the beam orientation with regards to the direction of travel
currentNode = MemberHelpers.DetermineNextNode(Member, LastNode, MoveDownstream);
// Check if the member is connected to a primary member
endHere = currentNode.ConnectedBeams.Any(b => this.PrimaryBeams.Contains(b));
// Get the next member
nextMember = null;
if (!endHere)
{
if (!currentNode.ConnectedMembers.Intersect(ParallelMembers).Where(m => m != Member).Any())
nextMember = null;
else
nextMember = currentNode.ConnectedMembers.Intersect(ParallelMembers).First(m => m != Member);
}
endHere = nextMember == null;
if (endHere)
{
if (!MoveDownstream)
members.UnionWith(this.GatherMembersBetweenPrimaryMembers(Member, ParallelMembers, currentNode, true));
}
else
{
IEnumerable<Member> output = this.GatherMembersBetweenPrimaryMembers(nextMember, ParallelMembers, currentNode, MoveDownstream);
if (MoveDownstream)
members.UnionWith(output);
}
return members;
}
/// <summary>
/// Gather member which provide continuity with the specified member, i.e. are parallel and unreleased, between columns.
/// </summary>
/// <param name="Member"></param>
/// <returns></returns>
private IEnumerable<Member> GatherMembersBetweenColumns(Member Member, IEnumerable<Member> ParallelMembers, Node LastNode = null, bool MoveDownstream = false)
{
bool endHere;
Node currentNode;
Beam nextBeam;
Member nextMember;
List<Member> members;
members = new List<Member>() {Member};
// Determine the next node depending on the beam orientation with regards to the direction of travel
currentNode = MemberHelpers.DetermineNextNode(Member, LastNode, MoveDownstream);
// Check if the member is released
endHere = currentNode.ConnectedBeams.Intersect(Member.Beams).Any(b => b.HasReleases);
// Get the next member
nextMember = null;
if (!endHere)
{
if (!currentNode.ConnectedMembers.Intersect(ParallelMembers).Where(m => m != Member).Any())
nextMember = null;
else
nextMember = currentNode.ConnectedMembers.Intersect(ParallelMembers).First(m => m != Member);
}
endHere = nextMember == null;
// Get the next beam
nextBeam = nextMember == null ? null : currentNode.ConnectedBeams.Intersect(nextMember.Beams).First();
// Check if the next Beam is released right after the current node
if (!endHere)
endHere = currentNode == nextBeam.StartNode ? nextBeam.StartRelease.IsReleased : nextBeam.EndRelease.IsReleased;
// Check if the member connects to a column
if (!endHere && currentNode.ConnectedMembers.Any(m => m.Type == MEMBERTYPE.COLUMN))
if (nextBeam != null && nextBeam.SectionProperty != currentNode.ConnectedBeams.Intersect(Member.Beams).First().SectionProperty)
endHere = true;
// Determine what to do depending on whether or not the chain stop here. if moving upstream, reverse and start gathering beams,
// if moving upstream, return the chain.
if (endHere)
{
if (!MoveDownstream)
members.AddRange(this.GatherMembersBetweenColumns(Member, ParallelMembers, currentNode, true));
}
else
{
IEnumerable<Member> output = this.GatherMembersBetweenColumns(nextMember, ParallelMembers, currentNode, MoveDownstream);
if (MoveDownstream)
members.AddRange(output);
}
return new HashSet<Member>(members).ToList();
}
/// <summary>
/// Determine the class of the specified member
/// </summary>
private MEMBERCLASS DetermineMemberClass(Member Member)
{
MEMBERCLASS memberClass;
if (this.PrimaryMembers.Contains(Member))
memberClass = MEMBERCLASS.PRIMARY;
else if (this.SecondaryMembers.Contains(Member))
memberClass = MEMBERCLASS.SECONDARY;
else if (this.TertiaryMembers.Contains(Member))
memberClass = MEMBERCLASS.TERTIARY;
else
memberClass = MEMBERCLASS.UNSPECIFIED;
return memberClass;
}
private bool CheckMemberRestraint(Member MemberToCheck, Beam StartBeam, MEMBERCLASS MemberClass)
{
bool output;
HashSet<Node> nodes;
// Gather all nodes connected to the beam to check or any beams parallel to it
nodes = new HashSet<Node>(BeamHelpers.GatherParallelBeams(StartBeam).SelectMany(b => new List<Node>() { b.StartNode, b.EndNode}));
// Check if any of the connected members are class above the current member
IEnumerable<Member> connectedMembers = nodes.SelectMany(n => n.ConnectedMembers).Where(m => m != null && m != MemberToCheck);
if (MemberClass == MEMBERCLASS.PRIMARY)
output = connectedMembers.Any(m => this.PrimaryMembers.Contains(m));
else if (MemberClass == MEMBERCLASS.SECONDARY)
output = connectedMembers.Any(m => this.PrimaryMembers.Contains(m) || this.SecondaryMembers.Contains(m));
else if (MemberClass == MEMBERCLASS.TERTIARY)
output = connectedMembers.Any(m => this.PrimaryMembers.Contains(m) || this.SecondaryMembers.Contains(m) || this.TertiaryMembers.Contains(m));
else
output = false;
return output;
}
private IEnumerable<BucklingLength> CalculateMemberUnsupportedLength(Member Member)
{
Node currentNode;
BucklingLength currentBucklingLength;
List<BucklingLength> bucklingLengths;
MEMBERCLASS memberClass;
bucklingLengths = new List<BucklingLength>();
memberClass = this.DetermineMemberClass(Member);
currentNode = Member.StartNode;
currentBucklingLength = new BucklingLength();
foreach (Beam beam in Member.Beams)
{
currentBucklingLength.Beams.Add(beam);
currentNode = (currentNode == beam.StartNode) ? beam.EndNode : beam.StartNode;
foreach (Beam connectedBeam in currentNode.ConnectedBeams.Where(cb => !Member.Beams.Contains(cb) && cb.Spec != BEAMSPEC.MEMBERTRUSS))
{
double connectionAngle;
bool memberInPlaneWithAxis;
memberInPlaneWithAxis = beam.CheckIBeamInAxisPlane(connectedBeam, BEAMAXIS.MAJOR);
connectionAngle = Math.Abs((beam.GetAngleRelativeToBeamAxis(connectedBeam, BEAMAXIS.MAJOR) + 90) % 180 - 90);
if (memberInPlaneWithAxis || (!memberInPlaneWithAxis && connectionAngle <= 45))
if (CheckMemberRestraint(Member, connectedBeam, memberClass))
{
if (currentBucklingLength.Beams.Count > 1)
bucklingLengths.Add(currentBucklingLength);
currentBucklingLength = new BucklingLength();
break;
}
}
}
if (currentBucklingLength.Beams.Count > 1)
bucklingLengths.Add(currentBucklingLength);
bucklingLengths.ForEach(bl => bl.Member = Member);
return bucklingLengths;
}
private IEnumerable<BucklingLength> CalculateMemberBucklingLengths(Member Member, BEAMAXIS Axis)
{
Node currentNode;
BucklingLength currentBucklingLength;
List<BucklingLength> bucklingLengths;
MEMBERCLASS memberClass;
bucklingLengths = new List<BucklingLength>();
memberClass = this.DetermineMemberClass(Member);
currentNode = Member.StartNode;
currentBucklingLength = new BucklingLength();
foreach (Beam beam in Member.Beams)
{
currentBucklingLength.Beams.Add(beam);
// Determine the next node in case one of the beams is flipped
currentNode = (currentNode == beam.StartNode) ? beam.EndNode : beam.StartNode;
// Loop through connected beams to see if one of them is a stability brace
foreach (Beam connectedBeam in currentNode.ConnectedBeams.Where(b => !Member.Beams.Contains(b) && this.StabilityBraces.Contains(b)))
{
double connectionAngle;
bool memberInPlaneWithAxis;
BEAMAXIS checkAxis;
// Check the connection plane and angle of the brace
checkAxis = Axis == BEAMAXIS.MAJOR ? BEAMAXIS.MINOR : BEAMAXIS.MAJOR;
memberInPlaneWithAxis = beam.CheckIBeamInAxisPlane(connectedBeam, checkAxis);
connectionAngle = Math.Abs((beam.GetAngleRelativeToBeamAxis(connectedBeam, checkAxis) + 90) % 180 - 90);
// Split the member if the brace connects in the correct place or within 45 of that plane
if (memberInPlaneWithAxis || (!memberInPlaneWithAxis && connectionAngle <= 45))
{
if (currentBucklingLength.Beams.Count > 1)
bucklingLengths.Add(currentBucklingLength);
currentBucklingLength = new BucklingLength();
break;
}
}
}
if (currentBucklingLength.Beams.Count > 1)
bucklingLengths.Add(currentBucklingLength);
bucklingLengths.ForEach(bl => bl.Member = Member);
return bucklingLengths;
}