/***************************************************/
public static List <ICurve> Visualize(this BarUniformlyDistributedLoad barUDL, double scaleFactor = 1.0, bool displayForces = true, bool displayMoments = true, bool asResultants = true)
{
List <ICurve> arrows = new List <ICurve>();
Vector forceVec = barUDL.Force * scaleFactor;
Vector momentVec = barUDL.Moment * scaleFactor;
double sqTol = Tolerance.Distance * Tolerance.Distance;
foreach (Bar bar in barUDL.Objects.Elements)
{
Cartesian system;
Vector[] forceVectors = BarForceVectors(bar, forceVec, momentVec, barUDL.Axis, barUDL.Projected, out system);
if (displayForces && forceVectors[0].SquareLength() > sqTol)
{
arrows.AddRange(ConnectedArrows(new List <ICurve> {
bar.Centreline()
}, forceVectors[0], asResultants, system, 1, true));
}
if (displayMoments && forceVectors[1].SquareLength() > sqTol)
{
arrows.AddRange(ConnectedArrows(new List <ICurve> {
bar.Centreline()
}, forceVectors[1], asResultants, system, 1, false));
}
}
return(arrows);
}
/***************************************************/
private bool CreateLoad(BarUniformlyDistributedLoad bhLoad)
{
List <Bar> bars = bhLoad.Objects.Elements.ToList();
string loadPat = GetAdapterId <string>(bhLoad.Loadcase);
double dist1 = 0;
double dist2 = 1;
int[] dirs = null;
double[] forceVals = null;
double[] momentVals = null;
switch (bhLoad.Axis)
{
case LoadAxis.Global:
if (bhLoad.Projected)
{
dirs = new int[] { 7, 8, 9 };
}
else
{
dirs = new int[] { 4, 5, 6 };
}
forceVals = bhLoad.Force.ToDoubleArray();
momentVals = bhLoad.Moment.ToDoubleArray();
break;
case LoadAxis.Local:
dirs = new int[] { 1, 2, 3 };
forceVals = bhLoad.Force.BarLocalAxisToCSI().ToDoubleArray();
momentVals = bhLoad.Moment.BarLocalAxisToCSI().ToDoubleArray();
break;
}
bool relDist = true;
string cSys = bhLoad.Axis.ToCSI();
eItemType type = eItemType.Objects;
bool replace = SAPPushConfig.ReplaceLoads;
foreach (Bar bhBar in bars)
{
string name = GetAdapterId <string>(bhBar);
bool replaceNow = replace;
for (int i = 0; i < dirs.Count(); i++)
{
if (m_model.FrameObj.SetLoadDistributed(name, loadPat, 1, dirs[i], dist1, dist2, forceVals[i], forceVals[i], cSys, relDist, replaceNow, type) != 0)
{
CreateElementError("BarLoad", bhBar.Name + dirs[i]);
}
replaceNow = false;
if (m_model.FrameObj.SetLoadDistributed(name, loadPat, 2, dirs[i], dist1, dist2, momentVals[i], momentVals[i], cSys, relDist, replaceNow, type) != 0)
{
CreateElementError("BarLoad", bhBar.Name + dirs[i]);
}
}
}
SetAdapterId(bhLoad, null);
return(true);
}
/***************************************************/
private IFLoadingLocalDistributed CreateLocalDistributedLine(BarUniformlyDistributedLoad distributedLoad, object[] lusasLines)
{
IFLoadcase assignedLoadcase = (IFLoadcase)d_LusasData.getLoadset(distributedLoad.Loadcase.AdapterId <int>(typeof(LusasId)));
IFLoadingLocalDistributed lusasLocalDistributed = CreateLocalDistributed(distributedLoad.Name,
"Line", assignedLoadcase, distributedLoad.Force, lusasLines);
int adapterIdName = lusasLocalDistributed.getID();
distributedLoad.SetAdapterId(typeof(LusasId), adapterIdName);
return(lusasLocalDistributed);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static BarUniformlyDistributedLoad ToBarUniformlyDistributed(IFLoading lusasDistributed,
IEnumerable<IFAssignment> lusasAssignments, Dictionary<string, Bar> bars)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable<Bar> assignedBars = GetLineAssignments(lusasAssignments, bars);
Vector forceVector = new Vector
{
X = lusasDistributed.getValue("WX"),
Y = lusasDistributed.getValue("WY"),
Z = lusasDistributed.getValue("WZ")
};
BarUniformlyDistributedLoad barUniformlyDistributed = null;
if (lusasDistributed.getAttributeType() == "Global Distributed Load")
{
Vector momentVector = new Vector
{
X = lusasDistributed.getValue("MX"),
Y = lusasDistributed.getValue("MY"),
Z = lusasDistributed.getValue("MZ")
};
barUniformlyDistributed = Engine.Structure.Create.BarUniformlyDistributedLoad(
loadcase,
assignedBars,
forceVector,
momentVector,
LoadAxis.Global,
true,
GetName(lusasDistributed));
}
else if (lusasDistributed.getAttributeType() == "Distributed Load")
{
barUniformlyDistributed = Engine.Structure.Create.BarUniformlyDistributedLoad(
loadcase,
assignedBars,
forceVector,
null,
LoadAxis.Local,
true,
GetName(lusasDistributed));
}
int adapterNameId = lusasDistributed.getID();
barUniformlyDistributed.SetAdapterId(typeof(LusasId), adapterNameId);
return barUniformlyDistributed;
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private bool CreateCollection(IEnumerable <ILoad> loads)
{
if (loads.Count() > 0)
{
int loadId = 0;
List <ILoad> loadList = loads.ToList();
//*****move this to adapter *****
modelData.FinishModification();
rf.ILoads rfloads = model.GetLoads();
//*******************************
var loadGroupByCase = loadList.GroupBy(load => load.Loadcase.Number);
foreach (var caseGroup in loadGroupByCase)
{
int loadcaseId = caseGroup.Key;
rf.ILoadCase rfLoadcase = rfloads.GetLoadCase(loadcaseId, rf.ItemAt.AtNo);
rfLoadcase.PrepareModification();
foreach (ILoad load in caseGroup)
{
loadId = GetAdapterId <int>(load);
if (load.GetType().IsAssignableFrom(typeof(BarUniformlyDistributedLoad)))
{
BarUniformlyDistributedLoad barLoad = load as BarUniformlyDistributedLoad;
rf.MemberLoad[] rfBarLoads = barLoad.ToRFEM(loadId, loadcaseId).ToArray();
foreach (rf.MemberLoad item in rfBarLoads)
{
rfLoadcase.SetMemberLoad(item);
}
}
//if (load.GetType().IsAssignableFrom(typeof(BarPointLoad)))
//{
// BarPointLoad barLoad = load as BarPointLoad;
// rf.MemberLoad[] rfBarLoads = barLoad.ToRFEM(loadId, loadcaseId).ToArray();
// foreach (rf.MemberLoad item in rfBarLoads)
// rfLoadcase.SetMemberLoad(item);
//}
}
rfLoadcase.FinishModification(); // <---- move to adapter
modelData.PrepareModification(); //<--- hack to avoid app lock issue
}
}
return(true);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static BarUniformlyDistributedLoad FromRFEM(this rf.MemberLoad rfMemberLoad, Loadcase bhLoadcase, oM.Base.BHoMGroup <Bar> objectGroup)
{
LoadAxis loadAxis;
bool projected;
string direction;
BarUniformlyDistributedLoad barUniformLoad = new BarUniformlyDistributedLoad();
barUniformLoad.Loadcase = bhLoadcase;
barUniformLoad.Objects = objectGroup;
barUniformLoad.SetAdapterId(typeof(RFEMId), rfMemberLoad.No);
GetLoadingParameters(rfMemberLoad, out loadAxis, out projected, out direction);
barUniformLoad.Axis = loadAxis;
barUniformLoad.Projected = projected;
switch (direction)
{
case "FX":
barUniformLoad.Force.X = rfMemberLoad.Magnitude1;
break;
case "FY":
barUniformLoad.Force.Y = rfMemberLoad.Magnitude1;
break;
case "FZ":
barUniformLoad.Force.Z = rfMemberLoad.Magnitude1;
break;
case "UX":
barUniformLoad.Moment.X = rfMemberLoad.Magnitude1;
break;
case "UY":
barUniformLoad.Moment.Y = rfMemberLoad.Magnitude1;
break;
case "UZ":
barUniformLoad.Moment.Z = rfMemberLoad.Magnitude1;
break;
default:
break;
}
return(barUniformLoad);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <ILoad> ReadBarUniformlyDistributedLoads(List <string> ids = null)
{
List <ILoad> barUniformlyDistributedLoads = new List <ILoad>();
object[] lusasGlobalDistributedLoads = d_LusasData.getAttributes("Global Distributed Load");
object[] lusasLocalDistributedLoads = d_LusasData.getAttributes("Distributed Load");
object[] lusasDistributedLoads = lusasGlobalDistributedLoads.Concat(
lusasLocalDistributedLoads).ToArray();
if (!(lusasDistributedLoads.Count() == 0))
{
List <Bar> barsList = ReadBars();
Dictionary <string, Bar> bars = barsList.ToDictionary(
x => x.AdapterId <string>(typeof(LusasId)));
List <IFLoadcase> allLoadcases = new List <IFLoadcase>();
for (int i = 0; i < lusasDistributedLoads.Count(); i++)
{
IFLoading lusasDistributedLoad = (IFLoading)lusasDistributedLoads[i];
IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases = GetLoadAssignments(
lusasDistributedLoad);
if (lusasDistributedLoad.getValue("type") == "Length" || lusasDistributedLoad.getValue("type") == "line")
{
foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases)
{
BarUniformlyDistributedLoad barUniformlyDistributedLoad =
Adapters.Lusas.Convert.ToBarUniformlyDistributed(
lusasDistributedLoad, groupedAssignment, bars);
List <string> analysisName = new List <string> {
lusasDistributedLoad.getAttributeType()
};
barUniformlyDistributedLoad.Tags = new HashSet <string>(analysisName);
barUniformlyDistributedLoads.Add(barUniformlyDistributedLoad);
}
}
}
}
return(barUniformlyDistributedLoads);
}
public static void SetLoad(cSapModel model, BarUniformlyDistributedLoad barUniformLoad, bool replace)
{
foreach (Bar bar in barUniformLoad.Objects.Elements)
{
for (int direction = 1; direction <= 3; direction++)
{
int ret = 1;
double val = direction == 1 ? barUniformLoad.Force.X : direction == 2 ? barUniformLoad.Force.Y : barUniformLoad.Force.Z; //note: etabs acts different then stated in API documentstion
if (val != 0)
{
string csiCaseName = CaseNameToCSI(barUniformLoad.Loadcase);
ret = model.FrameObj.SetLoadDistributed(bar.CustomData[AdapterId].ToString(), csiCaseName, 1, direction + 3, 0, 1, val, val, "Global", true, replace);
}
}
//moments ? does not exist in old toolkit either!
}
}
private bool CreateObject(BarUniformlyDistributedLoad uniDistributedLoad)
{
BarVaryingDistributedLoad vardistributedLoad = new BarVaryingDistributedLoad()
{
StartPosition = 0,
EndPosition = 0,
MomentAtStart = uniDistributedLoad.Moment,
MomentAtEnd = uniDistributedLoad.Moment,
ForceAtStart = uniDistributedLoad.Force,
ForceAtEnd = uniDistributedLoad.Force,
Loadcase = uniDistributedLoad.Loadcase,
Projected = uniDistributedLoad.Projected,
Axis = uniDistributedLoad.Axis,
Objects = uniDistributedLoad.Objects
};
return(CreateObject(vardistributedLoad));
}
/***************************************************/
public void SetLoad(BarUniformlyDistributedLoad barUniformLoad, bool replace)
{
string axis;
int shift;
GetDirectionData(barUniformLoad, out axis, out shift);
foreach (Bar bar in barUniformLoad.Objects.Elements)
{
bool stepReplace = replace;
string caseName = GetAdapterId <string>(barUniformLoad.Loadcase);
string barName = GetAdapterId <string>(bar);
for (int direction = 1; direction <= 3; direction++)
{
int ret = 1;
double val = direction == 1 ? barUniformLoad.Force.X : barUniformLoad.Axis == LoadAxis.Global ?
direction == 2 ? barUniformLoad.Force.Y : (shift == 6 ? -barUniformLoad.Force.Z : barUniformLoad.Force.Z) :
direction == 2 ? barUniformLoad.Force.Z : -barUniformLoad.Force.Y; //note: etabs acts different then stated in API documentstion
if (val != 0)
{
ret = m_model.FrameObj.SetLoadDistributed(barName, caseName, 1, direction + shift, 0, 1, val, val, axis, true, stepReplace);
stepReplace = false;
}
}
// Moment
for (int direction = 1; direction <= 3; direction++)
{
int ret = 1;
double val = direction == 1 ? barUniformLoad.Moment.X : barUniformLoad.Axis == LoadAxis.Global ?
direction == 2 ? barUniformLoad.Moment.Y : (shift == 6 ? -barUniformLoad.Moment.Z : barUniformLoad.Moment.Z) :
direction == 2 ? barUniformLoad.Moment.Z : -barUniformLoad.Moment.Y; //note: etabs acts different then stated in API documentstion
if (val != 0)
{
ret = m_model.FrameObj.SetLoadDistributed(barName, caseName, 2, direction + shift, 0, 1, val, val, axis, true, stepReplace);
stepReplace = false;
}
}
}
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <rf.MemberLoad> ToRFEM(this BarUniformlyDistributedLoad load, int loadId, int loadcaseId)
{
List <rf.MemberLoad> rfLoadList = new List <rf.MemberLoad>();
rf.MemberLoad rfLoad = new rf.MemberLoad();
rfLoad.Distribution = rf.LoadDistributionType.UniformType;
rfLoad.RelativeDistances = false;
rfLoad.ReferenceTo = rf.MemberLoadReferenceType.MembersType;
List <string> objectIds = load.Objects.Elements.Select(x => x.AdapterId <int>(typeof(RFEMId)).ToString()).ToList();
string objectIdString = string.Join(",", objectIds);
rfLoad.ObjectList = objectIdString;
rfLoad.IsValid = true;
rfLoad.Comment = "";
rfLoad.ID = "";
rfLoad.Tag = "";
if (load.Force.Length() == 0 & load.Moment.Length() == 0)
{
Engine.Base.Compute.RecordWarning("Zero forces set. No load pushed!");
return(rfLoadList);
}
if (load.Force.Length() != 0)
{
rfLoad.Type = rf.LoadType.ForceType;
if (load.Force.X != 0)
{
rfLoad.No = loadId;
rf.MemberLoad xLoad = rfLoad;
xLoad.Direction = load.Axis == LoadAxis.Global ? rf.LoadDirectionType.GlobalXType : rf.LoadDirectionType.LocalXType;
xLoad.Magnitude1 = load.Force.X;
rfLoadList.Add(xLoad);
loadId++;
}
if (load.Force.Y != 0)
{
rfLoad.No = loadId;
rf.MemberLoad yLoad = rfLoad;
yLoad.Direction = load.Axis == LoadAxis.Global ? rf.LoadDirectionType.GlobalYType : rf.LoadDirectionType.LocalYType;
yLoad.Magnitude1 = load.Force.Y;
rfLoadList.Add(yLoad);
loadId++;
}
if (load.Force.Z != 0)
{
rfLoad.No = loadId;
rf.MemberLoad zLoad = rfLoad;
zLoad.Direction = load.Axis == LoadAxis.Global ? rf.LoadDirectionType.GlobalZType : rf.LoadDirectionType.LocalZType;
zLoad.Magnitude1 = load.Force.Z;
rfLoadList.Add(zLoad);
loadId++;
}
}
if (load.Moment.Length() != 0)
{
rfLoad.Type = rf.LoadType.MomentType;
if (load.Moment.X != 0)
{
rfLoad.No = loadId;
rf.MemberLoad uxLoad = rfLoad;
uxLoad.Direction = load.Axis == LoadAxis.Global ? rf.LoadDirectionType.GlobalXType : rf.LoadDirectionType.LocalXType;
uxLoad.Magnitude1 = load.Moment.X;
rfLoadList.Add(uxLoad);
loadId++;
}
if (load.Moment.Y != 0)
{
rfLoad.No = loadId;
rf.MemberLoad uyLoad = rfLoad;
uyLoad.Direction = load.Axis == LoadAxis.Global ? rf.LoadDirectionType.GlobalXType : rf.LoadDirectionType.LocalXType;
uyLoad.Magnitude1 = load.Moment.X;
rfLoadList.Add(uyLoad);
loadId++;
}
if (load.Moment.X != 0)
{
rfLoad.No = loadId;
rf.MemberLoad uzLoad = rfLoad;
uzLoad.Direction = load.Axis == LoadAxis.Global ? rf.LoadDirectionType.GlobalXType : rf.LoadDirectionType.LocalXType;
uzLoad.Magnitude1 = load.Moment.X;
rfLoadList.Add(uzLoad);
loadId++;
}
}
return(rfLoadList);
}
public static LoadType LoadType(this BarUniformlyDistributedLoad load)
{
return(oM.Structure.Loads.LoadType.BarUniformLoad);
}
/***************************************************/
private List <ILoad> ReadBarLoad(List <Loadcase> loadcases)
{
List <ILoad> bhLoads = new List <ILoad>();
Dictionary <string, Bar> bhomBars = ReadBar().ToDictionary(x => GetAdapterId <string>(x));
string[] names = null;
string[] loadcase = null;
string[] CSys = null;
int[] myType = null;
int[] dir = null;
int nameCount = 0;
double[] rd1 = null;
double[] rd2 = null;
double[] dist1 = null;
double[] dist2 = null;
double[] val1 = null;
double[] val2 = null;
if (m_model.FrameObj.GetLoadDistributed("All", ref nameCount, ref names, ref loadcase, ref myType, ref CSys, ref dir, ref rd1, ref rd2, ref dist1, ref dist2, ref val1, ref val2, eItemType.Group) != 0)
{
return(bhLoads);
}
for (int i = 0; i < nameCount; i++)
{
Loadcase bhLoadcase = loadcases.FirstOrDefault(x => x.Name == loadcase[i]);
if (bhLoadcase == null)
{
continue;
}
if (dist1[i] != 0 || rd2[i] != 1 || Math.Abs(val1[i] - val2[i]) > Tolerance.Distance) //Is Varying
{
continue;
}
Vector force = Direction(dir[i], val1[i]);
BHoMGroup <Bar> barObjects = new BHoMGroup <Bar>()
{
Elements = { bhomBars[names[i]] }
};
BarUniformlyDistributedLoad bhLoad = new BarUniformlyDistributedLoad()
{
Loadcase = bhLoadcase,
Objects = barObjects
};
switch (myType[i])
{
case 1:
bhLoad.Force = force;
break;
case 2:
bhLoad.Moment = force;
break;
default:
BH.Engine.Base.Compute.RecordWarning("Could not create the load. It's not 'MyType'. MyType = " + myType[i].ToString());
break;
}
SetDirection(bhLoad, dir[i], CSys[i]);
bhLoads.Add(bhLoad);
}
return(bhLoads);
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private List <ILoad> ReadLoads(List <string> ids = null)
{
List <ILoad> loadList = new List <ILoad>();
if (ids == null)
{
List <rf.LoadCase> rfLoadcases = model.GetLoads().GetLoadCases().ToList();
rf.ILoads l = model.GetLoads();
int lcCount = l.GetLoadCaseCount();
Dictionary <int, Loadcase> bhLoadcaseDict = new Dictionary <int, Loadcase>();
bhLoadcaseDict = ReadLoadcases().Distinct().ToDictionary(x => x.Number, x => x);
Dictionary <string, Bar> bhBarDict = new Dictionary <string, Bar>();
bool barsRead = false;
for (int i = 0; i < lcCount; i++)
{
rf.LoadCase rfLoadcase = l.GetLoadCase(i, rf.ItemAt.AtIndex).GetData();
Loadcase bhLoadcase;
bhLoadcase = bhLoadcaseDict[rfLoadcase.Loading.No];
rf.MemberLoad[] rfMemberLoads = l.GetLoadCase(i, rf.ItemAt.AtIndex).GetMemberLoads();
if (rfMemberLoads.Length > 0)
{
if (!barsRead)
{
bhBarDict = ReadBars().ToDictionary(x => GetAdapterId(x).ToString(), x => x);
barsRead = true;
}
foreach (rf.MemberLoad rfLoad in rfMemberLoads)
{
List <string> barIds = BH.Engine.Adapters.RFEM.Compute.GetIdListFromString(rfLoad.ObjectList);
oM.Base.BHoMGroup <Bar> barGroup = new oM.Base.BHoMGroup <Bar>();
barGroup.Elements.AddRange(barIds.Where(k => bhBarDict.ContainsKey(k)).Select(k => bhBarDict[k]));
if (rfLoad.Distribution == rf.LoadDistributionType.UniformType)
{
BarUniformlyDistributedLoad barUniformLoad = rfLoad.FromRFEM(bhLoadcase, barGroup);
loadList.Add(barUniformLoad);
}
else if (rfLoad.Distribution == rf.LoadDistributionType.ConcentratedType)
{
BarPointLoad barPointLoad = new BarPointLoad();
//...
}
else
{
Engine.Base.Compute.RecordWarning("Load distribution of type: " + rfLoad.Distribution.ToString() + " is not supported!");
}
}
}
}
}
else
{
foreach (string id in ids)
{
//loadList.Add();
}
}
return(loadList);
}
private static List <ILoad> DistributedBarLoadsFromSt7(double loadX, double loadY, double loadZ, int distributionType, double barLength, double[] forces, double[] moments, Loadcase ldcase, Bar bar, bool projected, LoadAxis loadAxis)
{
List <ILoad> bhLoads = new List <ILoad>();
double a;
double b;
if (IsZeroSqLength(forces))
{
a = moments[4];
b = moments[5];
}
else
{
a = forces[4];
b = forces[5];
}
ILoad bhLoad;
ILoad bhLoad2;
ILoad bhLoad3;
switch (distributionType)
{
case St7.dlConstant:
bhLoad = new BarUniformlyDistributedLoad()
{
Moment = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
Force = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad);
break;
case St7.dlLinear:
if (moments[0] == moments[1] && forces[0] == forces[1] && a == 0 && b == 0)
{
bhLoad = new BarUniformlyDistributedLoad()
{
Moment = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
Force = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
}
else
{
bhLoad = new BarVaryingDistributedLoad()
{
StartPosition = barLength * a,
EndPosition = barLength * b,
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[1],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[1],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
}
bhLoads.Add(bhLoad);
break;
case St7.dlTriangular:
bhLoad = new BarVaryingDistributedLoad()
{
StartPosition = 0,
EndPosition = barLength * (1 - a),
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[2],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[2],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad);
bhLoad2 = new BarVaryingDistributedLoad()
{
StartPosition = barLength * a,
EndPosition = 0,
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[3],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[3],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad2);
break;
case St7.dlThreePoint0:
bhLoad = new BarVaryingDistributedLoad()
{
StartPosition = 0,
EndPosition = barLength * (1 - a),
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[2],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[2],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad);
bhLoad2 = new BarVaryingDistributedLoad()
{
StartPosition = barLength * a,
EndPosition = barLength * b,
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[1],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[1],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad2);
break;
case St7.dlThreePoint1:
bhLoad = new BarVaryingDistributedLoad()
{
StartPosition = barLength * a,
EndPosition = barLength * b,
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[1],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[1],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad);
bhLoad2 = new BarVaryingDistributedLoad()
{
StartPosition = barLength * (1 - b),
EndPosition = 0,
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[1],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[3],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[1],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[3],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad2);
break;
case St7.dlTrapezoidal:
bhLoad = new BarVaryingDistributedLoad()
{
StartPosition = 0,
EndPosition = barLength * (1 - a),
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[2],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[2],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad);
bhLoad2 = new BarVaryingDistributedLoad()
{
StartPosition = barLength * a,
EndPosition = barLength * b,
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[0],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[1],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[0],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[1],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad2);
bhLoad3 = new BarVaryingDistributedLoad()
{
StartPosition = barLength * (1 - b),
EndPosition = 0,
MomentAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[1],
MomentAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * moments[3],
ForceAtStart = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[1],
ForceAtEnd = BH.Engine.Geometry.Create.Vector(loadX, loadY, loadZ) * forces[3],
Loadcase = ldcase,
Projected = projected,
Axis = loadAxis,
Objects = new BHoMGroup <Bar>()
{
Elements = { bar }
}
};
bhLoads.Add(bhLoad3);
break;
}
return(bhLoads);
}
