private static bool Add1dLoadsWithAppId(string entityKeyword, string loadCaseKeyword, IEnumerable <GsaLoadBeamUdl> gsaLoads, ref List <Structural1DLoad> structural1DLoads)
{
var gsaGroups = gsaLoads.GroupBy(gl => new { ApplicationId = gl.ApplicationId.Substring(0, gl.ApplicationId.IndexOf("_")), gl.LoadCaseIndex });
foreach (var group in gsaGroups)
{
var gList = group.ToList();
var applicationId = gList[0].ApplicationId.Substring(0, gList[0].ApplicationId.IndexOf("_"));
var name = (gList.Any(gl => !string.IsNullOrEmpty(gl.Name))) ? gList.FirstOrDefault(gl => !string.IsNullOrEmpty(gl.Name)).Name : "";
//Assume the element refs are the same for those with application IDs - so just take the indices of the first record and resolve them to application IDs for entities
var elementRefs = gList[0].Entities.Select(ei => Initialiser.AppResources.Cache.GetApplicationId(entityKeyword, ei)).Where(aid => !string.IsNullOrEmpty(aid)).ToList();
var loadCaseRef = Initialiser.AppResources.Cache.GetApplicationId(loadCaseKeyword, gList[0].LoadCaseIndex.Value);
var loadings = gList.Select(gl => Helper.GsaLoadToLoading(gl.LoadDirection, gl.Load.Value)).ToList();
var combinedLoading = new StructuralVectorSix(Enumerable.Range(0, 6).Select(i => loadings.Sum(l => l.Value[i])));
var load = new Structural1DLoad()
{
ApplicationId = applicationId,
Name = name,
ElementRefs = elementRefs,
LoadCaseRef = loadCaseRef,
Loading = combinedLoading
};
structural1DLoads.Add(load);
}
return(true);
}
private static bool Add0dLoadsWithAppId(string nodeKeyword, string loadCaseKeyword, IEnumerable <GsaLoadNode> gsaLoads,
List <GSANode> gsaNodes, ref List <Structural0DLoad> structural0DLoads, ref List <int> nodeIndicesReferenced)
{
var summaries = new List <D0LoadingSummary>();
//All loads here have an application ID and axis is set to GLOBAL
foreach (var gl in gsaLoads)
{
//Assume an underscore is the end of the original Application ID of the Speckle object that created up to 6 rows of 0D loads
var appId = gl.ApplicationId.Substring(0, gl.ApplicationId.IndexOf("_"));
var relevantGsaNodes = gsaNodes.Where(n => gl.NodeIndices.Any(ni => ni == n.GSAId)).ToList();
foreach (var n in relevantGsaNodes)
{
summaries.Add(new D0LoadingSummary(gl.Index.Value, gl.LoadCaseIndex, n.GSAId)
{
ApplicationId = appId
});
}
}
var groups = summaries.GroupBy(s => new { s.LoadCaseIndex, s.ApplicationId });
var allNodeIndices = nodeIndicesReferenced.ToList();
foreach (var group in groups)
{
var indices = group.Select(i => i.Index).Distinct().ToList();
var nodeIndices = group.Select(i => i.NodeIndex).Where(i => i != null).Distinct().ToList();
allNodeIndices.AddRange(nodeIndices.Where(ni => ni.HasValue && !allNodeIndices.Contains(ni.Value)).Select(ni => ni.Value));
var nodeRefs = nodeIndices.Select(ni => SpeckleStructuralGSA.Helper.GetApplicationId(nodeKeyword, ni.Value)).OrderBy(r => r).ToList();
var loadCaseRef = SpeckleStructuralGSA.Helper.GetApplicationId(loadCaseKeyword, group.First().LoadCaseIndex.Value);
var applicationId = group.First().ApplicationId;
var name = string.Join("-", group.Where(i => !string.IsNullOrEmpty(i.Name)).Select(i => i.Name));
var loadings = indices.Select(i => gsaLoads.First(l => l.Index == i)).Select(gl => Helper.GsaLoadToLoading(gl.LoadDirection, gl.Value.Value)).ToList();
var combinedLoading = new StructuralVectorSix(Enumerable.Range(0, 6).Select(i => loadings.Sum(l => l.Value[i])));
var obj = new Structural0DLoad()
{
ApplicationId = applicationId, Loading = combinedLoading, NodeRefs = nodeRefs, LoadCaseRef = loadCaseRef
};
if (!string.IsNullOrEmpty(name))
{
obj.Name = name;
}
Helper.AddCustomStructuralProperty(obj, indices.Count() == 1 ? "NativeId" : "NativeIds",
indices.Count() == 1 ? (object)indices.First().ToString() : indices.Select(i => i.ToString()).ToList());
structural0DLoads.Add(obj);
}
nodeIndicesReferenced = allNodeIndices;
return(true);
}
public static Dictionary <AxisDirection6, double> ExplodeLoading(StructuralVectorSix loading)
{
var valueByDir = new Dictionary <AxisDirection6, double>();
var loadDirSeq = Enum.GetValues(typeof(AxisDirection6)).Cast <AxisDirection6>().Where(v => v != AxisDirection6.NotSet).ToList();
for (var i = 0; i < loadDirSeq.Count(); i++)
{
if (loading.Value[i] != 0)
{
valueByDir.Add(loadDirSeq[i], loading.Value[i]);
}
}
return(valueByDir);
}
public static StructuralVectorSix AxisDirDictToStructuralVectorSix(Dictionary <AxisDirection6, double> d)
{
if (d == null || d.Keys.Count() == 0)
{
return(null);
}
var v = new StructuralVectorSix();
var values = new double[6];
for (int i = 0; i < AxisDirs.Count(); i++)
{
if (d.ContainsKey(AxisDirs[i]))
{
values[i] = d[AxisDirs[i]];
}
}
v.Value = values.ToList();
return(v);
}
//public static readonly AxisDirection6[] loadDirSeq = new AxisDirection6[] { AxisDirection6.X, AxisDirection6.Y, AxisDirection6.Z, AxisDirection6.XX, AxisDirection6.YY, AxisDirection6.ZZ };
public static bool IsValidLoading(StructuralVectorSix loading)
{
return(loading != null && loading.Value != null && loading.Value.Count() == 6 && loading.Value.Any(v => v != 0));
}
public static List <SpeckleObject> ToSpeckle(this BoundaryConditions myRestraint)
{
var points = new List <XYZ>();
var restraintType = myRestraint.GetBoundaryConditionsType();
if (restraintType == BoundaryConditionsType.Point)
{
var point = myRestraint.Point;
points.Add(point);
}
else if (restraintType == BoundaryConditionsType.Line)
{
var curve = myRestraint.GetCurve();
points.Add(curve.GetEndPoint(0));
points.Add(curve.GetEndPoint(1));
}
else if (restraintType == BoundaryConditionsType.Area)
{
var loops = myRestraint.GetLoops();
foreach (var loop in loops)
{
foreach (var curve in loop)
{
points.Add(curve.GetEndPoint(0));
points.Add(curve.GetEndPoint(1));
}
}
points = points.Distinct().ToList();
}
var coordinateSystem = myRestraint.GetDegreesOfFreedomCoordinateSystem();
var axis = new StructuralAxis(
new StructuralVectorThree(new double[] { coordinateSystem.BasisX.X, coordinateSystem.BasisX.Y, coordinateSystem.BasisX.Z }),
new StructuralVectorThree(new double[] { coordinateSystem.BasisY.X, coordinateSystem.BasisY.Y, coordinateSystem.BasisY.Z }),
new StructuralVectorThree(new double[] { coordinateSystem.BasisZ.X, coordinateSystem.BasisZ.Y, coordinateSystem.BasisZ.Z })
);
var restraint = new StructuralVectorBoolSix(new bool[6]);
var stiffness = new StructuralVectorSix(new double[6]);
var listOfParams = new BuiltInParameter[] {
BuiltInParameter.BOUNDARY_DIRECTION_X,
BuiltInParameter.BOUNDARY_DIRECTION_Y,
BuiltInParameter.BOUNDARY_DIRECTION_Z,
BuiltInParameter.BOUNDARY_DIRECTION_ROT_X,
BuiltInParameter.BOUNDARY_DIRECTION_ROT_Y,
BuiltInParameter.BOUNDARY_DIRECTION_ROT_Z
};
var listOfSpringParams = new BuiltInParameter[] {
BuiltInParameter.BOUNDARY_RESTRAINT_X,
BuiltInParameter.BOUNDARY_RESTRAINT_Y,
BuiltInParameter.BOUNDARY_RESTRAINT_Z,
BuiltInParameter.BOUNDARY_RESTRAINT_ROT_X,
BuiltInParameter.BOUNDARY_RESTRAINT_ROT_Y,
BuiltInParameter.BOUNDARY_RESTRAINT_ROT_Z,
};
for (var i = 0; i < 6; i++)
{
switch (myRestraint.get_Parameter(listOfParams[i]).AsInteger())
{
case 0:
restraint.Value[i] = true;
break;
case 1:
restraint.Value[i] = false;
break;
case 2:
stiffness.Value[i] = myRestraint.get_Parameter(listOfSpringParams[i]).AsDouble();
break;
}
}
restraint.GenerateHash();
stiffness.GenerateHash();
var myNodes = new List <SpeckleObject>();
foreach (var point in points)
{
var myPoint = (SpeckleCoreGeometryClasses.SpecklePoint)SpeckleCore.Converter.Serialise(point);
var myNode = new StructuralNode();
myNode.basePoint = myPoint;
myNode.Axis = axis;
myNode.Restraint = restraint;
myNode.Stiffness = stiffness;
myNodes.Add(myNode);
}
return(myNodes);
}
private List <string> SpringTypeCommandPieces(StructuralSpringPropertyType structuralSpringPropertyType, StructuralVectorSix stiffness, double dampingRatio)
{
var dampingRatioStr = dampingRatio.ToString();
var stiffnessToUse = (stiffness == null) ? new StructuralVectorSix(new double[] { 0, 0, 0, 0, 0, 0 }) : stiffness;
switch (structuralSpringPropertyType)
{
case StructuralSpringPropertyType.Torsional:
return(new List <string> {
"TORSIONAL", stiffnessToUse.Value[3].ToString(), dampingRatioStr
}); //xx stiffness only
case StructuralSpringPropertyType.Tension:
return(new List <string> {
"TENSION", stiffnessToUse.Value[0].ToString(), dampingRatioStr
});
case StructuralSpringPropertyType.Compression:
return(new List <string> {
"COMPRESSION", stiffnessToUse.Value[0].ToString(), dampingRatioStr
});
//Pasting GWA commands for CONNECT doesn't seem to work yet in GSA
//case StructuralSpringPropertyType.Connector:
// return new List<string> { "CONNECT", "0", dampingRatioStr }; // Not sure what the argument after CONNECT is
case StructuralSpringPropertyType.Lockup:
return(new List <string> {
"LOCKUP", stiffnessToUse.Value[0].ToString(), dampingRatioStr, "0", "0"
}); // Not sure what the last two arguments are
case StructuralSpringPropertyType.Gap:
return(new List <string> {
"GAP", stiffnessToUse.Value[0].ToString(), dampingRatioStr
});
case StructuralSpringPropertyType.Axial:
return(new List <string> {
"AXIAL", stiffnessToUse.Value[0].ToString(), dampingRatioStr
});
case StructuralSpringPropertyType.Friction:
//Coeff of friction (2nd-last) isn't supported yet
return(new List <string> {
"FRICTION", stiffnessToUse.Value[0].ToString(), stiffness.Value[1].ToString(), stiffnessToUse.Value[2].ToString(), "0", dampingRatioStr
});
default:
var ls = new List <string>()
{
"GENERAL"
};
for (var i = 0; i < 6; i++)
{
ls.Add("0"); //Curve
ls.Add((stiffnessToUse == null) ? "0" : stiffnessToUse.Value[i].ToString());
}
ls.Add(dampingRatioStr);
return(ls);
}
}
public static List <SpeckleObject> ToSpeckle(this LineLoad myLineLoad)
{
var myLoad = new Structural1DLoadLine
{
Name = myLineLoad.Name
};
var points = myLineLoad.GetCurve().Tessellate();
myLoad.Value = new List <double>();
foreach (var p in points)
{
myLoad.Value.Add(p.X / Scale);
myLoad.Value.Add(p.Y / Scale);
myLoad.Value.Add(p.Z / Scale);
}
var forces = new StructuralVectorSix(new double[6]);
forces.Value[0] = (myLineLoad.ForceVector1.X + myLineLoad.ForceVector2.X) / 2;
forces.Value[1] = (myLineLoad.ForceVector1.Y + myLineLoad.ForceVector2.Y) / 2;
forces.Value[2] = (myLineLoad.ForceVector1.Z + myLineLoad.ForceVector2.Z) / 2;
forces.Value[3] = (myLineLoad.MomentVector1.X + myLineLoad.MomentVector2.X) / 2;
forces.Value[4] = (myLineLoad.MomentVector1.Y + myLineLoad.MomentVector2.Y) / 2;
forces.Value[5] = (myLineLoad.MomentVector1.Z + myLineLoad.MomentVector2.Z) / 2;
if (myLineLoad.OrientTo == LoadOrientTo.HostLocalCoordinateSystem)
{
var hostTransform = myLineLoad.HostElement.GetLocalCoordinateSystem();
var b0 = hostTransform.get_Basis(0);
var b1 = hostTransform.get_Basis(1);
var b2 = hostTransform.get_Basis(2);
var fx = forces.Value[0] * b0.X + forces.Value[1] * b1.X + forces.Value[2] * b2.X;
var fy = forces.Value[0] * b0.Y + forces.Value[1] * b1.Y + forces.Value[2] * b2.Y;
var fz = forces.Value[0] * b0.Z + forces.Value[1] * b1.Z + forces.Value[2] * b2.Z;
var mx = forces.Value[3] * b0.X + forces.Value[4] * b1.X + forces.Value[5] * b2.X;
var my = forces.Value[3] * b0.Y + forces.Value[4] * b1.Y + forces.Value[5] * b2.Y;
var mz = forces.Value[3] * b0.Z + forces.Value[4] * b1.Z + forces.Value[5] * b2.Z;
forces = new StructuralVectorSix(new double[] { fx, fy, fz, mx, my, mz });
}
else if (myLineLoad.OrientTo == LoadOrientTo.WorkPlane)
{
var workPlane = ((SketchPlane)Doc.GetElement(myLineLoad.WorkPlaneId)).GetPlane();
var b0 = workPlane.XVec;
var b1 = workPlane.YVec;
var b2 = workPlane.Normal;
var fx = forces.Value[0] * b0.X + forces.Value[1] * b1.X + forces.Value[2] * b2.X;
var fy = forces.Value[0] * b0.Y + forces.Value[1] * b1.Y + forces.Value[2] * b2.Y;
var fz = forces.Value[0] * b0.Z + forces.Value[1] * b1.Z + forces.Value[2] * b2.Z;
var mx = forces.Value[3] * b0.X + forces.Value[4] * b1.X + forces.Value[5] * b2.X;
var my = forces.Value[3] * b0.Y + forces.Value[4] * b1.Y + forces.Value[5] * b2.Y;
var mz = forces.Value[3] * b0.Z + forces.Value[4] * b1.Z + forces.Value[5] * b2.Z;
forces = new StructuralVectorSix(new double[] { fx, fy, fz, mx, my, mz });
}
myLoad.Loading = forces;
var myLoadCase = new StructuralLoadCase
{
Name = myLineLoad.LoadCaseName,
ApplicationId = myLineLoad.LoadCase.UniqueId
};
switch (myLineLoad.LoadCategoryName)
{
case "Dead Loads":
myLoadCase.CaseType = StructuralLoadCaseType.Dead;
break;
case "Live Loads":
myLoadCase.CaseType = StructuralLoadCaseType.Live;
break;
case "Seismic Loads":
myLoadCase.CaseType = StructuralLoadCaseType.Earthquake;
break;
case "Snow Loads":
myLoadCase.CaseType = StructuralLoadCaseType.Snow;
break;
case "Wind Loads":
myLoadCase.CaseType = StructuralLoadCaseType.Wind;
break;
default:
myLoadCase.CaseType = StructuralLoadCaseType.Generic;
break;
}
myLoad.LoadCaseRef = myLoadCase.ApplicationId;
myLoad.ApplicationId = myLineLoad.UniqueId;
return(new List <SpeckleObject>()
{
myLoad, myLoadCase
});
}
