/***************************************************/
private void GetOneSideBarReleaseArrays(Constraint6DOF constraint, out bool[] fixities, out double[] values)
{
fixities = new bool[6];
//Note: Etabs does not follow the same convention as the BHoM. Different notation is also used
//where 1,2 and 3 is used instead of X,Y, and Z. The convention is as follows: 1 = X, 2 = Z and 3 = Y in etabs
fixities[0] = constraint.TranslationX != DOFType.Fixed;
fixities[1] = constraint.TranslationZ != DOFType.Fixed;
fixities[2] = constraint.TranslationY != DOFType.Fixed;
fixities[3] = constraint.RotationX != DOFType.Fixed;
fixities[4] = constraint.RotationZ != DOFType.Fixed;
fixities[5] = constraint.RotationY != DOFType.Fixed;
values = new double[6];
values[0] = constraint.TranslationalStiffnessX;
values[1] = constraint.TranslationalStiffnessZ;
values[2] = constraint.TranslationalStiffnessY;
values[3] = constraint.RotationalStiffnessX;
values[4] = constraint.RotationalStiffnessZ;
values[5] = constraint.RotationalStiffnessY;
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Node ToNode(this IFPoint lusasPoint,
HashSet <string> groupNames, Dictionary <string, Constraint6DOF> constraint6DOFs)
{
HashSet <string> tags = new HashSet <string>(IsMemberOf(lusasPoint, groupNames));
List <string> supportAssignments = GetAttributeAssignments(lusasPoint, "Support");
Constraint6DOF nodeConstraint = null;
if (!(supportAssignments.Count() == 0))
{
constraint6DOFs.TryGetValue(supportAssignments[0], out nodeConstraint);
}
Node node = new Node
{
Position = new Point {
X = lusasPoint.getX(), Y = lusasPoint.getY(), Z = lusasPoint.getZ()
},
Name = "",
Support = nodeConstraint
};
node.Tags = tags;
string adapterID = lusasPoint.getID().ToString();
node.SetAdapterId(typeof(LusasId), adapterID);
return(node);
}
/***************************************************/
private List <Node> ReadNode(List <string> ids = null)
{
List <Node> nodeList = new List <Node>();
int nameCount = 0;
string[] nameArr = { };
m_model.PointObj.GetNameList(ref nameCount, ref nameArr);
ids = FilterIds(ids, nameArr);
foreach (string id in ids)
{
ETABSId etabsIdFragment = new ETABSId();
etabsIdFragment.Id = id;
double x, y, z;
x = y = z = 0;
bool[] restraint = new bool[6];
double[] spring = new double[6];
m_model.PointObj.GetCoordCartesian(id, ref x, ref y, ref z);
m_model.PointObj.GetRestraint(id, ref restraint);
m_model.PointObj.GetSpring(id, ref spring);
Constraint6DOF support = GetConstraint6DOF(restraint, spring);
Node bhNode = new Node {
Position = new oM.Geometry.Point()
{
X = x, Y = y, Z = z
}, Support = support
};
//Label and story
string label = "";
string story = "";
string guid = null;
if (m_model.PointObj.GetLabelFromName(id, ref label, ref story) == 0)
{
etabsIdFragment.Label = label;
etabsIdFragment.Story = story;
}
if (m_model.PointObj.GetGUID(id, ref guid) == 0)
{
etabsIdFragment.PersistentId = guid;
}
bhNode.SetAdapterId(etabsIdFragment);
nodeList.Add(bhNode);
}
return(nodeList);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Node Node(Cartesian coordinates, string name = "", Constraint6DOF constraint = null)
{
return(new Node
{
Coordinates = coordinates.Clone(),
Name = name,
Constraint = constraint
});
}
private static void FlipEndPoints(Bar bar)
{
// Flip the endpoints
Node tempNode = bar.StartNode;
bar.StartNode = bar.EndNode;
bar.EndNode = tempNode;
// Flip orientationAngle
bar.OrientationAngle = -bar.OrientationAngle;
if (bar.IsVertical())
{
bar.OrientationAngle += Math.PI;
}
// Flip Offsets
if (bar.Offset != null)
{
Vector tempV = bar.Offset.Start;
bar.Offset.Start = bar.Offset.End;
bar.Offset.End = tempV;
if (bar.Offset.Start != null)
{
bar.Offset.Start.X *= -1;
}
if (bar.Offset.End != null)
{
bar.Offset.End.X *= -1;
}
if (!bar.IsVertical())
{
if (bar.Offset.Start != null)
{
bar.Offset.Start.Y *= -1;
}
if (bar.Offset.End != null)
{
bar.Offset.End.Y *= -1;
}
}
}
// mirror the section
// not possible to push to ETABS afterwards if we did
// warning for asymetric sections?
// Flip Release
if (bar.Release != null)
{
Constraint6DOF tempC = bar.Release.StartRelease;
bar.Release.StartRelease = bar.Release.EndRelease;
bar.Release.EndRelease = tempC;
}
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private IFAttribute CreateSupport(Constraint6DOF constraint)
{
if (!Engine.Adapters.Lusas.Query.CheckIllegalCharacters(constraint.DescriptionOrName()))
{
return(null);
}
IFAttribute lusasSupport = null;
if (d_LusasData.existsAttribute("Support", constraint.DescriptionOrName()))
{
lusasSupport = d_LusasData.getAttribute("Support", constraint.DescriptionOrName());
}
else
{
lusasSupport = d_LusasData.createSupportStructural(constraint.DescriptionOrName());
List <string> releaseNames = new List <string> {
"U", "V", "W", "THX", "THY", "THZ"
};
List <double> stiffness = new List <double> {
constraint.TranslationalStiffnessX, constraint.TranslationalStiffnessY,
constraint.TranslationalStiffnessZ,
constraint.RotationalStiffnessX, constraint.RotationalStiffnessY,
constraint.RotationalStiffnessZ
};
bool[] fixities = constraint.Fixities();
for (int i = 0; i < releaseNames.Count(); i++)
{
if (fixities[i])
{
lusasSupport.setValue(releaseNames[i], "R");
}
else if (stiffness[i] == 0)
{
lusasSupport.setValue(releaseNames[i], "F");
}
else
{
lusasSupport.setValue(releaseNames[i], "S");
lusasSupport.setValue(releaseNames[i] + "stiff", stiffness[i]);
}
}
}
if (lusasSupport != null)
{
int adapterIdName = lusasSupport.getID();
constraint.SetAdapterId(typeof(LusasId), adapterIdName);
return(lusasSupport);
}
return(null);
}
public static Node Node(Cartesian coordinates, string name = "", Constraint6DOF support = null)
{
return(coordinates.IsNull() ? null : new Node
{
Position = coordinates.Origin,
Orientation = (Basis)coordinates,
Name = name,
Support = support
});
}
public static bool IsNull(this Constraint6DOF constraint, string msg = "", [CallerMemberName] string methodName = "Method")
{
if (constraint == null)
{
ErrorMessage(methodName, "Constraint6DOF", msg);
return(true);
}
return(false);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Edge Edge(ICurve curve, Constraint6DOF support = null, Constraint4DOF release = null, string name = "")
{
return(new Edge
{
Curve = curve,
Support = support,
Release = release,
Name = name
});
}
public static double[] ElasticValues(this Constraint6DOF constraint)
{
return(constraint.IsNull() ? null : new double[]
{
constraint.TranslationalStiffnessX,
constraint.TranslationalStiffnessY,
constraint.TranslationalStiffnessZ,
constraint.RotationalStiffnessX,
constraint.RotationalStiffnessY,
constraint.RotationalStiffnessZ
});
}
public static bool[] Fixities(this Constraint6DOF constraint)
{
return(constraint.IsNull() ? null : new bool[]
{
constraint.TranslationX == DOFType.Fixed,
constraint.TranslationY == DOFType.Fixed,
constraint.TranslationZ == DOFType.Fixed,
constraint.RotationX == DOFType.Fixed,
constraint.RotationY == DOFType.Fixed,
constraint.RotationZ == DOFType.Fixed
});
}
public static string Description(this Constraint6DOF constraint)
{
string desc = constraint.TranslationX.DofSign() + constraint.TranslationY.DofSign() + constraint.TranslationZ.DofSign() +
constraint.RotationX.DofSign() + constraint.RotationY.DofSign() + constraint.RotationZ.DofSign();
if (constraint.IsNumericallyDependent())
{
desc += $"- {constraint.TranslationalStiffnessX:G3}, {constraint.TranslationalStiffnessY:G3}, {constraint.TranslationalStiffnessZ:G3}, " +
$"{constraint.RotationalStiffnessX:G3}, {constraint.RotationalStiffnessY:G3}, {constraint.RotationalStiffnessZ:G3}";
}
return(desc);
}
public static BarRelease BarReleasePinPin(string name = "PinPin")
{
Constraint6DOF endRelease = PinConstraint6DOF();
endRelease.RotationX = DOFType.Fixed;
return(new BarRelease
{
StartRelease = PinConstraint6DOF(),
EndRelease = endRelease,
Name = name
});
}
public static BarRelease BarReleasePinSlip(string name = "PinSlip")
{
Constraint6DOF startRelease = PinConstraint6DOF();
startRelease.RotationX = DOFType.Fixed;
return(new BarRelease
{
StartRelease = startRelease,
EndRelease = Constraint6DOF(false, true, true, false, false, false, "Slip"),
Name = name
});
}
/***************************************************/
private static Constraint6DOF SetConstraint(List <DOFType> releaseType)
{
Constraint6DOF constraint = new Constraint6DOF
{
TranslationX = releaseType[0],
TranslationY = releaseType[1],
TranslationZ = releaseType[2],
RotationX = releaseType[3],
RotationY = releaseType[4],
RotationZ = releaseType[5]
};
return(constraint);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <Constraint6DOF> Read6DOFConstraints(List <string> ids = null)
{
object[] lusasSupports = d_LusasData.getAttributes("Support");
List <Constraint6DOF> constraints6DOF = new List <Constraint6DOF>();
for (int i = 0; i < lusasSupports.Count(); i++)
{
IFSupportStructural lusasSupport = (IFSupportStructural)lusasSupports[i];
Constraint6DOF constraint6DOF = Adapters.Lusas.Convert.ToConstraint6DOF(lusasSupport);
if (constraint6DOF != null)
{
constraints6DOF.Add(constraint6DOF);
}
}
return(constraints6DOF);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static void ToCSI(this Constraint6DOF support, ref bool[] restraint, ref double[] spring)
{
restraint = new bool[6];
restraint[0] = support.TranslationX == DOFType.Fixed;
restraint[1] = support.TranslationY == DOFType.Fixed;
restraint[2] = support.TranslationZ == DOFType.Fixed;
restraint[3] = support.RotationX == DOFType.Fixed;
restraint[4] = support.RotationY == DOFType.Fixed;
restraint[5] = support.RotationZ == DOFType.Fixed;
spring = new double[6];
spring[0] = support.TranslationalStiffnessX;
spring[1] = support.TranslationalStiffnessY;
spring[2] = support.TranslationalStiffnessZ;
spring[3] = support.RotationalStiffnessX;
spring[4] = support.RotationalStiffnessY;
spring[5] = support.RotationalStiffnessZ;
}
/***************************************************/
private static BarRelease GetBarRelease(IFMeshLine lusasLineMesh)
{
object[] startReleases = lusasLineMesh.getValue("start");
object[] endReleases = lusasLineMesh.getValue("end");
List <DOFType> startReleaseType = GetConstraints(startReleases);
List <DOFType> endReleaseType = GetConstraints(endReleases);
Constraint6DOF startConstraint = SetConstraint(startReleaseType);
Constraint6DOF endConstraint = SetConstraint(endReleaseType);
BarRelease barRelease = new BarRelease
{
StartRelease = startConstraint,
EndRelease = endConstraint
};
return(barRelease);
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
//The List<string> in the methods below can be changed to a list of any type of identification more suitable for the toolkit
//If no ids are provided, the convention is to return all elements of the type
private List <Node> ReadNodes(List <string> ids = null)
{
int err = 0;
int nodeCount = 0;
List <Node> nodes = new List <Node>();
double[] XYZ = new double[3];
err = St7.St7GetTotal(1, St7.tyNODE, ref nodeCount);
if (!St7Error(err))
{
return(nodes);
}
for (int nn = 0; nn < nodeCount; nn++)
{
int nodeId = nn + 1;
// getting node coordinates
err = St7.St7GetNodeXYZ(1, nodeId, XYZ);
if (!St7ErrorCustom(err, "Could not get a position of node: " + nodeId.ToString()))
{
continue;
}
// getting node restraints
// !!! LOCAL RESTRAINTS ARE NOT IMPLEMENTED !!!! read UCS and write it to Orientation property in Node
int ucsId = 1;
int[] restraints = new int[6];
double[] enforcedDispls = new double[6];
List <bool> bhFixed = new List <bool>();
err = St7.St7GetNodeRestraint6(1, nodeId, 1, ref ucsId, restraints, enforcedDispls);
bhFixed = restraints.Select(rst => rst == St7.btTrue).ToList();
double[] translationStiff = new double[3];
err = St7.St7GetNodeKTranslation3F(1, nodeId, 1, ref ucsId, translationStiff);
double[] rotationStiff = new double[3];
err = St7.St7GetNodeKRotation3F(1, nodeId, 1, ref ucsId, rotationStiff);
List <double> stiffnessVals = new List <double>();
stiffnessVals.AddRange(translationStiff);
stiffnessVals.AddRange(rotationStiff);
Constraint6DOF bhRestraint = BH.Engine.Structure.Create.Constraint6DOF("", bhFixed, stiffnessVals);
Node bhNode = BH.Engine.Structure.Create.Node(BH.Engine.Geometry.Create.Point(XYZ[0], XYZ[1], XYZ[2]), "", bhRestraint);
SetAdapterId(bhNode, nodeId);
nodes.Add(bhNode);
}
return(nodes);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Constraint6DOF ToConstraint6DOF(this IFSupportStructural lusasAttribute)
{
List <string> releaseNames = new List <string> {
"U", "V", "W", "THX", "THY", "THZ"
};
List <bool> fixity = new List <bool>();
List <double> stiffness = new List <double>();
foreach (string releaseName in releaseNames)
{
string fixityValue = lusasAttribute.getValue(releaseName);
if (fixityValue == "F")
{
fixity.Add(false);
stiffness.Add(0.0);
}
else if (fixityValue == "R")
{
fixity.Add(true);
stiffness.Add(0.0);
}
else if (fixityValue == "S")
{
fixity.Add(false);
double stiffnessValue = lusasAttribute.getValue(releaseName + "stiff");
stiffness.Add(stiffnessValue);
}
}
string attributeName = GetName(lusasAttribute);
Constraint6DOF constraint6DOF = BH.Engine.Structure.Create.Constraint6DOF(
attributeName, fixity, stiffness);
int adapterNameId = lusasAttribute.getID();
constraint6DOF.SetAdapterId(typeof(LusasId), adapterNameId);
return(constraint6DOF);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static void GetSAPConstraint(this Node node, ref bool[] restraint, ref double[] spring)
{
Constraint6DOF bhConstraint = node.Support;
restraint = new bool[6];
restraint[0] = bhConstraint.TranslationX == DOFType.Fixed;
restraint[1] = bhConstraint.TranslationY == DOFType.Fixed;
restraint[2] = bhConstraint.TranslationZ == DOFType.Fixed;
restraint[3] = bhConstraint.RotationX == DOFType.Fixed;
restraint[4] = bhConstraint.RotationY == DOFType.Fixed;
restraint[5] = bhConstraint.RotationZ == DOFType.Fixed;
spring = new double[6];
spring[0] = bhConstraint.TranslationalStiffnessX;
spring[1] = bhConstraint.TranslationalStiffnessY;
spring[2] = bhConstraint.TranslationalStiffnessZ;
spring[3] = bhConstraint.RotationalStiffnessX;
spring[4] = bhConstraint.RotationalStiffnessY;
spring[5] = bhConstraint.RotationalStiffnessZ;
}
public static Constraint6DOF GetConstraint6DOF(bool[] restraint, double[] springs)
{
Constraint6DOF bhConstraint = new Constraint6DOF();
bhConstraint.TranslationX = restraint[0] == true ? DOFType.Fixed : DOFType.Free;
bhConstraint.TranslationY = restraint[1] == true ? DOFType.Fixed : DOFType.Free;
bhConstraint.TranslationZ = restraint[2] == true ? DOFType.Fixed : DOFType.Free;
bhConstraint.RotationX = restraint[3] == true ? DOFType.Fixed : DOFType.Free;
bhConstraint.RotationY = restraint[4] == true ? DOFType.Fixed : DOFType.Free;
bhConstraint.RotationZ = restraint[5] == true ? DOFType.Fixed : DOFType.Free;
bhConstraint.TranslationalStiffnessX = springs[0];
bhConstraint.TranslationalStiffnessY = springs[1];
bhConstraint.TranslationalStiffnessZ = springs[2];
bhConstraint.RotationalStiffnessX = springs[3];
bhConstraint.RotationalStiffnessY = springs[4];
bhConstraint.RotationalStiffnessZ = springs[5];
return(bhConstraint);
}
/***************************************************/
public static BarRelease GetBarRelease(bool[] startRelease, double[] startSpring, bool[] endRelease, double[] endSpring)
{
Constraint6DOF bhStartRelease = new Constraint6DOF();
bhStartRelease.TranslationX = GetDofType(startRelease, startSpring, 0);
bhStartRelease.TranslationY = GetDofType(startRelease, startSpring, 2);
bhStartRelease.TranslationZ = GetDofType(startRelease, startSpring, 1);
bhStartRelease.RotationX = GetDofType(startRelease, startSpring, 3);
bhStartRelease.RotationY = GetDofType(startRelease, startSpring, 5);
bhStartRelease.RotationZ = GetDofType(startRelease, startSpring, 4);
bhStartRelease.TranslationalStiffnessX = startSpring[0];
bhStartRelease.TranslationalStiffnessY = startSpring[2];
bhStartRelease.TranslationalStiffnessZ = startSpring[1];
bhStartRelease.RotationalStiffnessX = startSpring[3];
bhStartRelease.RotationalStiffnessY = startSpring[5];
bhStartRelease.RotationalStiffnessZ = startSpring[4];
Constraint6DOF bhEndRelease = new Constraint6DOF();
bhEndRelease.TranslationX = GetDofType(endRelease, endSpring, 0);
bhEndRelease.TranslationY = GetDofType(endRelease, endSpring, 2);
bhEndRelease.TranslationZ = GetDofType(endRelease, endSpring, 1);
bhEndRelease.RotationX = GetDofType(endRelease, endSpring, 3);
bhEndRelease.RotationY = GetDofType(endRelease, endSpring, 5);
bhEndRelease.RotationZ = GetDofType(endRelease, endSpring, 4);
bhEndRelease.TranslationalStiffnessX = endSpring[0];
bhEndRelease.TranslationalStiffnessY = endSpring[2];
bhEndRelease.TranslationalStiffnessZ = endSpring[1];
bhEndRelease.RotationalStiffnessX = endSpring[3];
bhEndRelease.RotationalStiffnessY = endSpring[5];
bhEndRelease.RotationalStiffnessZ = endSpring[4];
BarRelease barRelease = new BarRelease()
{
StartRelease = bhStartRelease, EndRelease = bhEndRelease
};
return(barRelease);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static rf.NodalSupport ToRFEM(this Constraint6DOF constraint, int constraintId, int nodeId)
{
rf.NodalSupport rfConstraint = new rf.NodalSupport();
rfConstraint.No = constraintId;
rfConstraint.NodeList = nodeId.ToString();//<-- id reference to node(s) required for writing constraint to RFEM
//Translation - RFEM unit is N/m
if (constraint.TranslationX == DOFType.Free)
{
rfConstraint.SupportConstantX = 0;
}
else if (constraint.TranslationX == DOFType.Fixed)
{
rfConstraint.SupportConstantX = -1;
}
else
{
rfConstraint.SupportConstantX = constraint.TranslationalStiffnessX;
}
if (constraint.TranslationY == DOFType.Free)
{
rfConstraint.SupportConstantY = 0;
}
else if (constraint.TranslationY == DOFType.Fixed)
{
rfConstraint.SupportConstantY = -1;
}
else
{
rfConstraint.SupportConstantY = constraint.TranslationalStiffnessY;
}
if (constraint.TranslationZ == DOFType.Free)
{
rfConstraint.SupportConstantZ = 0;
}
else if (constraint.TranslationZ == DOFType.Fixed)
{
rfConstraint.SupportConstantZ = -1;
}
else
{
rfConstraint.SupportConstantZ = constraint.TranslationalStiffnessZ;
}
//Rotation - RFEM unit is Nm/Rad
if (constraint.RotationX == DOFType.Free)
{
rfConstraint.RestraintConstantX = 0;
}
else if (constraint.RotationX == DOFType.Fixed)
{
rfConstraint.RestraintConstantX = -1;
}
else
{
rfConstraint.RestraintConstantX = constraint.RotationalStiffnessX;
}
if (constraint.RotationY == DOFType.Free)
{
rfConstraint.RestraintConstantY = 0;
}
else if (constraint.RotationY == DOFType.Fixed)
{
rfConstraint.RestraintConstantY = -1;
}
else
{
rfConstraint.RestraintConstantY = constraint.RotationalStiffnessY;
}
if (constraint.RotationZ == DOFType.Free)
{
rfConstraint.RestraintConstantZ = 0;
}
else if (constraint.RotationZ == DOFType.Fixed)
{
rfConstraint.RestraintConstantZ = -1;
}
else
{
rfConstraint.RestraintConstantZ = constraint.RotationalStiffnessZ;
}
return(rfConstraint);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
//Add methods for converting to BHoM from the specific software types.
//Only do this if possible to do without any com-calls or similar to the adapter
public static Constraint6DOF FromRFEM(this rf.NodalSupport rfConstraint)
{
Constraint6DOF bhConstraint = new Constraint6DOF();
//Translation
if (rfConstraint.SupportConstantX == 0)
{
bhConstraint.TranslationX = DOFType.Free;
}
if (rfConstraint.SupportConstantX == -1)
{
bhConstraint.TranslationX = DOFType.Fixed;
}
else
{
bhConstraint.TranslationalStiffnessX = rfConstraint.SupportConstantX;
}
if (rfConstraint.SupportConstantY == 0)
{
bhConstraint.TranslationY = DOFType.Free;
}
if (rfConstraint.SupportConstantY == -1)
{
bhConstraint.TranslationY = DOFType.Fixed;
}
else
{
bhConstraint.TranslationalStiffnessY = rfConstraint.SupportConstantY;
}
if (rfConstraint.SupportConstantZ == 0)
{
bhConstraint.TranslationZ = DOFType.Free;
}
if (rfConstraint.SupportConstantZ == -1)
{
bhConstraint.TranslationZ = DOFType.Fixed;
}
else
{
bhConstraint.TranslationalStiffnessZ = rfConstraint.SupportConstantZ;
}
//Rotation
if (rfConstraint.RestraintConstantX == 0)
{
bhConstraint.RotationX = DOFType.Free;
}
if (rfConstraint.RestraintConstantX == -1)
{
bhConstraint.RotationX = DOFType.Fixed;
}
else
{
bhConstraint.RotationalStiffnessX = rfConstraint.RestraintConstantX;
}
if (rfConstraint.RestraintConstantY == 0)
{
bhConstraint.RotationY = DOFType.Free;
}
if (rfConstraint.RestraintConstantY == -1)
{
bhConstraint.RotationY = DOFType.Fixed;
}
else
{
bhConstraint.RotationalStiffnessY = rfConstraint.RestraintConstantY;
}
if (rfConstraint.RestraintConstantZ == 0)
{
bhConstraint.RotationZ = DOFType.Free;
}
if (rfConstraint.RestraintConstantZ == -1)
{
bhConstraint.RotationZ = DOFType.Fixed;
}
else
{
bhConstraint.RotationalStiffnessZ = rfConstraint.RestraintConstantZ;
}
bhConstraint.SetAdapterId(typeof(RFEMId), rfConstraint.No);
return(bhConstraint);
}
public static BarRelease BarRelease(Constraint6DOF startConstraint, Constraint6DOF endConstraint, string name = "")
{
return(new BarRelease {
StartRelease = startConstraint, EndRelease = endConstraint, Name = name
});
}
public static Node Node(Cartesian coordinates, int freedomeCase, string name = "", Constraint6DOF support = null)
{
Node nd = new Node();
nd.Position = coordinates.Origin;
nd.Orientation = (Basis)coordinates;
nd.Name = name;
nd.CustomData["Freedom"] = freedomeCase;
nd.Support = support;
return(nd);
}
public static Node Node(Point position, string name = "", Constraint6DOF support = null)
{
return(Node((Cartesian)position, name, support));
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private List <Bar> ReadBars(List <string> ids = null)
{
int err = 0;
List <Bar> beams = new List <Bar>();
Dictionary <int, ISectionProperty> allBeamProperties = ReadSectionProperties().ToDictionary(x => GetAdapterId <int>(x));
Dictionary <int, Node> allNodes = ReadNodes().ToDictionary(x => GetAdapterId <int>(x));
int beamCount = 0;
err = St7.St7GetTotal(1, St7.tyBEAM, ref beamCount);
if (!St7ErrorCustom(err, "Could not get total number of beams."))
{
return(beams);
}
for (int bm = 0; bm < beamCount; bm++)
{
// Getting nodes for a beam
int beamId = bm + 1;
int[] bmNodes = new int[St7.kMaxElementNode + 1];
err = St7.St7GetElementConnection(1, St7.tyBEAM, beamId, bmNodes);
if (!St7ErrorCustom(err, "Could not get nodes for a beam " + beamId.ToString()))
{
continue;
}
if (bmNodes[0] != 2) // checking number of nodes bmNodes[0]
{
BH.Engine.Base.Compute.RecordError("Number of nodes doesn't equal 2 for beam N: " + beamId.ToString());
return(beams);
}
Node nd1 = allNodes[bmNodes[1]];
Node nd2 = allNodes[bmNodes[2]];
// getting a property for a beam
int beamPropNum = 0;
err = St7.St7GetElementProperty(1, St7.ptBEAMPROP, beamId, ref beamPropNum);
if (!St7ErrorCustom(err, "Could not get property for a beam " + beamId.ToString()))
{
continue;
}
ISectionProperty prop = allBeamProperties.ContainsKey(beamPropNum)? allBeamProperties[beamPropNum] : null;
//// getting an orientation vector
//double[] beamAxes = new double[9];
//err = St7.St7GetBeamAxisSystem(1, beamId, St7.btTrue, beamAxes);
//if (!St7ErrorCustom(err, "Could not get local axes for a beam " + beamId.ToString())) continue;
//Vector i2 = BH.Engine.Geometry.Create.Vector(beamAxes[3], beamAxes[4], beamAxes[5]); // normal vector
//Vector i3 = BH.Engine.Geometry.Create.Vector(beamAxes[6], beamAxes[7], beamAxes[8]); // vector along the beam
//Vector reference = Vector.ZAxis;
//if (Abs(1 - Query.DotProduct(i3, Vector.ZAxis)) < 0.001) reference = i3.CrossProduct(Vector.YAxis); // if beam is vertical use X or -X axis as reference
//double orientationAngle = reference.Angle(i2, new Plane { Normal = i3 });
double[] orientationAngle = new double[1];
err = St7.St7GetBeamReferenceAngle1(1, beamId, orientationAngle);
int[] restrTranslationStart = new int[3];
int[] restrTranslationEnd = new int[3];
int[] restrRotationStart = new int[3];
int[] restrRotationEnd = new int[3];
double[] stiffTranslationStart = new double[3];
double[] stiffTranslationEnd = new double[3];
double[] stiffRotationStart = new double[3];
double[] stiffRotationEnd = new double[3];
// getting beam releases
err = St7.St7GetBeamTRelease3(1, beamId, 1, restrTranslationStart, stiffTranslationStart);
if (err != St7.ERR7_NoError)
{
restrTranslationStart = new int[] { 1, 1, 1 }
}
; // fixed if not set
err = St7.St7GetBeamRRelease3(1, beamId, 1, restrRotationStart, stiffRotationStart);
if (err != St7.ERR7_NoError)
{
restrRotationStart = new int[] { 1, 1, 1 }
}
; // fixed if not set
List <bool> beamStartRestraint = restrTranslationStart.Concat(restrRotationStart).Select(rst => rst == St7.brFixed).ToList();
List <double> stiffnessValsStart = stiffTranslationStart.Concat(stiffRotationStart).ToList();
err = St7.St7GetBeamTRelease3(1, beamId, 2, restrTranslationEnd, stiffTranslationEnd);
if (err != St7.ERR7_NoError)
{
restrTranslationEnd = new int[] { 1, 1, 1 }
}
; // fixed if not set
err = St7.St7GetBeamRRelease3(1, beamId, 2, restrRotationEnd, stiffRotationEnd);
if (err != St7.ERR7_NoError)
{
restrRotationEnd = new int[] { 1, 1, 1 }
}
; // fixed if not set
List <bool> beamEndRestraint = restrTranslationEnd.Concat(restrRotationEnd).Select(rst => rst == St7.brFixed).ToList();
List <double> stiffnessValsEnd = stiffTranslationEnd.Concat(stiffRotationEnd).ToList();
Constraint6DOF startRelease = BH.Engine.Structure.Create.Constraint6DOF("", beamStartRestraint, stiffnessValsStart);
Constraint6DOF endRelease = BH.Engine.Structure.Create.Constraint6DOF("", beamEndRestraint, stiffnessValsEnd);
BarRelease barRelease = BH.Engine.Structure.Create.BarRelease(startRelease, endRelease);
Bar bar = BH.Engine.Structure.Create.Bar(nd1, nd2, prop, orientationAngle[0] * System.Math.PI / 180, barRelease);
SetAdapterId(bar, beamId);
beams.Add(bar);
}
return(beams);
}
/***************************************************/
}
}
public static bool IsNumericallyDependent(this Constraint6DOF constraint)
{
if (constraint.IsNull())
{
return(false);
}
if (constraint.TranslationX.IsNumericallyDependent())
{
return(true);
}
if (constraint.TranslationY.IsNumericallyDependent())
{
return(true);
}
if (constraint.TranslationZ.IsNumericallyDependent())
{
return(true);
}
if (constraint.RotationX.IsNumericallyDependent())
{
return(true);
}
if (constraint.RotationY.IsNumericallyDependent())
{
return(true);
}
if (constraint.RotationZ.IsNumericallyDependent())
{
return(true);
}
if (constraint.TranslationalStiffnessX != 0)
{
return(true);
}
if (constraint.TranslationalStiffnessY != 0)
{
return(true);
}
if (constraint.TranslationalStiffnessZ != 0)
{
return(true);
}
if (constraint.RotationalStiffnessX != 0)
{
return(true);
}
if (constraint.RotationalStiffnessY != 0)
{
return(true);
}
if (constraint.RotationalStiffnessZ != 0)
{
return(true);
}
return(false);
}
