/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static PointDisplacement ToPointDisplacement(IFLoading lusasPrescribedDisplacement,
IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Node> nodes)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable <Node> assignedNodes = GetPointAssignments(lusasAssignments, nodes);
Vector translationVector = new Vector
{
X = lusasPrescribedDisplacement.getValue("U"),
Y = lusasPrescribedDisplacement.getValue("V"),
Z = lusasPrescribedDisplacement.getValue("W")
};
Vector rotationVector = new Vector
{
X = lusasPrescribedDisplacement.getValue("THX"),
Y = lusasPrescribedDisplacement.getValue("THY"),
Z = lusasPrescribedDisplacement.getValue("THZ")
};
PointDisplacement pointDisplacement = BH.Engine.Structure.Create.PointDisplacement(
loadcase, assignedNodes, translationVector, rotationVector, LoadAxis.Global,
GetName(lusasPrescribedDisplacement));
int adapterNameId = lusasPrescribedDisplacement.getID();
pointDisplacement.SetAdapterId(typeof(LusasId), adapterNameId);
// Needs to be a bit here that determines whether it is global or local - actually this cannot be done as the
//attribute is applied to a group, and within the group the axis could local or global
return(pointDisplacement);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static GravityLoad ToGravityLoad(IFLoading lusasGravityLoad,
IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Node> nodes,
Dictionary <string, Bar> bars,
Dictionary <string, Panel> panels)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
Vector gravityVector = new Vector
{
X = lusasGravityLoad.getValue("accX"),
Y = lusasGravityLoad.getValue("accY"),
Z = lusasGravityLoad.getValue("accZ")
};
IEnumerable <BHoMObject> assignedObjects = GetGeometryAssignments(
lusasAssignments, nodes, bars, panels);
GravityLoad gravityLoad = Engine.Structure.Create.GravityLoad(
loadcase, gravityVector, assignedObjects, GetName(lusasGravityLoad));
int adapterNameId = lusasGravityLoad.getID();
gravityLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(gravityLoad);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static AreaUniformTemperatureLoad ToAreaTempratureLoad(
IFLoading lusasTemperatureLoad,
IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Panel> panels)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
double temperatureChange = lusasTemperatureLoad.getValue("T")
- lusasTemperatureLoad.getValue("T0");
IEnumerable <IAreaElement> assignedPanels = GetSurfaceAssignments(lusasAssignments, panels);
AreaUniformTemperatureLoad AreaUniformTemperatureLoad = BH.Engine.Structure.Create.AreaUniformTemperatureLoad(
loadcase,
temperatureChange,
assignedPanels,
LoadAxis.Local,
false,
GetName(lusasTemperatureLoad));
int adapterNameId = lusasTemperatureLoad.getID();
AreaUniformTemperatureLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(AreaUniformTemperatureLoad);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static BarUniformTemperatureLoad ToBarUniformTemperatureLoad(
IFLoading lusasTemperatureLoad,
IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Bar> bars)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
double temperatureChange = lusasTemperatureLoad.getValue("T")
- lusasTemperatureLoad.getValue("T0");
IEnumerable <Bar> assignedBars = GetLineAssignments(lusasAssignments, bars);
BarUniformTemperatureLoad barUniformTemperatureLoad = Engine.Structure.Create.BarUniformTemperatureLoad(
loadcase,
temperatureChange,
assignedBars,
LoadAxis.Local,
false,
GetName(lusasTemperatureLoad));
int adapterNameId = lusasTemperatureLoad.getID();
barUniformTemperatureLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(barUniformTemperatureLoad);
}
private List <ILoad> ReadAreaUniformTemperatureLoads(List <string> ids = null)
{
/***************************************************/
/**** Private Methods ****/
/***************************************************/
List <ILoad> areaUniformTemperatureLoads = new List <ILoad>();
object[] lusasTemperatureLoads = d_LusasData.getAttributes("Temperature");
if (!(lusasTemperatureLoads.Count() == 0))
{
List <Panel> panelsList = ReadPanels();
Dictionary <string, Panel> panels = panelsList.ToDictionary(
x => x.AdapterId <string>(typeof(LusasId)));
List <IFLoadcase> allLoadcases = new List <IFLoadcase>();
for (int i = 0; i < lusasTemperatureLoads.Count(); i++)
{
IFLoading lusasTemperatureLoad = (IFLoading)lusasTemperatureLoads[i];
IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases =
GetLoadAssignments(lusasTemperatureLoad);
foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases)
{
List <IFAssignment> surfaceAssignments = new List <IFAssignment>();
foreach (IFAssignment assignment in groupedAssignment)
{
IFSurface trySurf = assignment.getDatabaseObject() as IFSurface;
if (trySurf != null)
{
surfaceAssignments.Add(assignment);
}
}
List <string> analysisName = new List <string> {
lusasTemperatureLoad.getAttributeType()
};
if (surfaceAssignments.Count != 0)
{
AreaUniformTemperatureLoad areaUniformTemperatureLoad =
Adapters.Lusas.Convert.ToAreaTempratureLoad(
lusasTemperatureLoad, groupedAssignment, panels);
areaUniformTemperatureLoad.Tags = new HashSet <string>(analysisName);
areaUniformTemperatureLoads.Add(areaUniformTemperatureLoad);
}
}
}
}
return(areaUniformTemperatureLoads);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <ILoad> ReadBarUniformTemperatureLoads(List <string> ids = null)
{
List <ILoad> barUniformTemperatureLoads = new List <ILoad>();
object[] lusasTemperatureLoads = d_LusasData.getAttributes("Temperature");
if (!(lusasTemperatureLoads.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 < lusasTemperatureLoads.Count(); i++)
{
IFLoading lusasTemperatureLoad = (IFLoading)lusasTemperatureLoads[i];
IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases =
GetLoadAssignments(lusasTemperatureLoad);
foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases)
{
List <IFAssignment> assignments = new List <IFAssignment>();
foreach (IFAssignment assignment in groupedAssignment)
{
IFLine tryLine = assignment.getDatabaseObject() as IFLine;
if (tryLine != null)
{
assignments.Add(assignment);
}
}
List <string> analysisName = new List <string> {
lusasTemperatureLoad.getAttributeType()
};
if (assignments.Count != 0)
{
BarUniformTemperatureLoad barUniformTemperatureLoad =
Adapter.Adapters.Lusas.Convert.ToBarUniformTemperatureLoad(
lusasTemperatureLoad, groupedAssignment, bars);
barUniformTemperatureLoad.Tags = new HashSet <string>(analysisName);
barUniformTemperatureLoads.Add(barUniformTemperatureLoad);
}
}
}
}
return(barUniformTemperatureLoads);
}
/***************************************************/
/**** 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 List <ILoad> ReadAreaUniformlyDistributedLoads(List <string> ids = null)
{
/***************************************************/
/**** Private Methods ****/
/***************************************************/
List <ILoad> areaUniformlyDistributedLoads = 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 <Panel> panelsList = ReadPanels();
Dictionary <string, Panel> panels = panelsList.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];
if (lusasDistributedLoad.getValue("type") == "Area" || lusasDistributedLoad.getValue("type") == "all")
{
IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases =
GetLoadAssignments(lusasDistributedLoad);
foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases)
{
AreaUniformlyDistributedLoad areaUniformlyDistributedLoad =
Adapters.Lusas.Convert.ToAreaUniformlyDistributed(
lusasDistributedLoad, groupedAssignment, panels);
List <string> analysisName = new List <string> {
lusasDistributedLoad.getAttributeType()
};
areaUniformlyDistributedLoad.Tags = new HashSet <string>(analysisName);
areaUniformlyDistributedLoads.Add(areaUniformlyDistributedLoad);
}
}
}
}
return(areaUniformlyDistributedLoads);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static AreaUniformlyDistributedLoad ToAreaUniformlyDistributed(
IFLoading lusasDistributed, IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Panel> panels)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable <IAreaElement> assignedPanels = GetSurfaceAssignments(
lusasAssignments, panels);
Vector pressureVector = new Vector
{
X = lusasDistributed.getValue("WX"),
Y = lusasDistributed.getValue("WY"),
Z = lusasDistributed.getValue("WZ")
};
AreaUniformlyDistributedLoad areaUniformlyDistributedLoad = null;
if (lusasDistributed.getAttributeType() == "Global Distributed Load")
{
areaUniformlyDistributedLoad = Engine.Structure.Create.AreaUniformlyDistributedLoad(
loadcase,
pressureVector,
assignedPanels,
LoadAxis.Global,
true,
GetName(lusasDistributed));
}
else if (lusasDistributed.getAttributeType() == "Distributed Load")
{
areaUniformlyDistributedLoad = Engine.Structure.Create.AreaUniformlyDistributedLoad(
loadcase,
pressureVector,
assignedPanels,
LoadAxis.Local,
true,
GetName(lusasDistributed));
}
int adapterNameId = lusasDistributed.getID();
areaUniformlyDistributedLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(areaUniformlyDistributedLoad);
}
/***************************************************/
/**** 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);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <ILoad> ReadGravityLoads(List <string> ids = null)
{
List <ILoad> gravityLoads = new List <ILoad>();
object[] lusasBodyForces = d_LusasData.getAttributes("Body Force Load");
if (!(lusasBodyForces.Count() == 0))
{
List <Node> nodesList = ReadNodes();
List <Bar> barsList = ReadBars();
List <Panel> panelsList = ReadPanels();
Dictionary <string, Node> nodes = nodesList.ToDictionary(
x => x.AdapterId <string>(typeof(LusasId)));
Dictionary <string, Bar> bars = barsList.ToDictionary(
x => x.AdapterId <string>(typeof(LusasId)));
Dictionary <string, Panel> panels = panelsList.ToDictionary(
x => x.AdapterId <string>(typeof(LusasId)));
List <IFLoadcase> allLoadcases = new List <IFLoadcase>();
for (int i = 0; i < lusasBodyForces.Count(); i++)
{
IFLoading lusasBodyForce = (IFLoading)lusasBodyForces[i];
IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases =
GetLoadAssignments(lusasBodyForce);
foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases)
{
List <string> analysisName = new List <string> {
lusasBodyForce.getAttributeType()
};
GravityLoad gravityLoad = Adapters.Lusas.Convert.ToGravityLoad(
lusasBodyForce, groupedAssignment, nodes, bars, panels);
gravityLoad.Tags = new HashSet <string>(analysisName);
gravityLoads.Add(gravityLoad);
}
}
}
return(gravityLoads);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <ILoad> ReadBarVaryingDistributedLoads(List <string> ids = null)
{
List <ILoad> barDistributedLoads = new List <ILoad>();
object[] lusasInternalBeamDistributedLoads = d_LusasData.getAttributes("Beam Distributed Load");
if (lusasInternalBeamDistributedLoads.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 < lusasInternalBeamDistributedLoads.Count(); i++)
{
IFLoading lusasInternalBeamDistributedLoad = (IFLoading)lusasInternalBeamDistributedLoads[i];
IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases =
GetLoadAssignments(lusasInternalBeamDistributedLoad);
foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases)
{
BarVaryingDistributedLoad barDistributedLoad =
Adapters.Lusas.Convert.ToBarDistributedLoad(
lusasInternalBeamDistributedLoad, groupedAssignment, bars);
if (barDistributedLoad != null)
{
List <string> analysisName = new List <string> {
lusasInternalBeamDistributedLoad.getAttributeType()
};
barDistributedLoad.Tags = new HashSet <string>(analysisName);
barDistributedLoads.Add(barDistributedLoad);
}
}
}
}
return(barDistributedLoads);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static BarPointLoad ToBarPointLoad(IFLoading lusasBarPointLoad,
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 = lusasBarPointLoad.getValue("PX"),
Y = lusasBarPointLoad.getValue("PY"),
Z = lusasBarPointLoad.getValue("PZ")
};
Vector momentVector = new Vector
{
X = lusasBarPointLoad.getValue("MX"),
Y = lusasBarPointLoad.getValue("MY"),
Z = lusasBarPointLoad.getValue("MZ")
};
double forcePosition = lusasBarPointLoad.getValue("Distance");
BarPointLoad barPointLoad;
barPointLoad = Engine.Structure.Create.BarPointLoad(
loadcase,
forcePosition,
assignedBars,
forceVector,
momentVector,
LoadAxis.Global,
GetName(lusasBarPointLoad));
int adapterNameId = lusasBarPointLoad.getID();
barPointLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(barPointLoad);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <ILoad> ReadPointDisplacements(List <string> ids = null)
{
List <ILoad> pointDisplacements = new List <ILoad>();
object[] lusasPrescribedDisplacements = d_LusasData.getAttributes("Prescribed Load");
if (!(lusasPrescribedDisplacements.Count() == 0))
{
List <Node> nodesList = ReadNodes();
Dictionary <string, Node> nodes = nodesList.ToDictionary(
x => x.AdapterId <string>(typeof(LusasId)));
List <IFLoadcase> allLoadcases = new List <IFLoadcase>();
for (int i = 0; i < lusasPrescribedDisplacements.Count(); i++)
{
IFLoading lusasPrescribedDisplacement = (IFLoading)lusasPrescribedDisplacements[i];
IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases =
GetLoadAssignments(lusasPrescribedDisplacement);
foreach (IEnumerable <IFAssignment> groupedAssignment in groupedByLoadcases)
{
PointDisplacement pointDisplacement =
Adapters.Lusas.Convert.ToPointDisplacement(
lusasPrescribedDisplacement, groupedAssignment, nodes);
List <string> analysisName = new List <string> {
lusasPrescribedDisplacement.getAttributeType()
};
pointDisplacement.Tags = new HashSet <string>(analysisName);
pointDisplacements.Add(pointDisplacement);
}
}
}
return(pointDisplacements);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static PointLoad ToPointLoad(
IFLoading lusasPointLoad, IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Node> nodes)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable <Node> assignedNodes = GetPointAssignments(lusasAssignments, nodes);
Vector forceVector = new Vector
{
X = lusasPointLoad.getValue("px"),
Y = lusasPointLoad.getValue("py"),
Z = lusasPointLoad.getValue("pz")
};
Vector momentVector = new Vector
{
X = lusasPointLoad.getValue("mx"),
Y = lusasPointLoad.getValue("my"),
Z = lusasPointLoad.getValue("mz")
};
PointLoad pointLoad = Engine.Structure.Create.PointLoad(
loadcase,
assignedNodes,
forceVector,
momentVector,
LoadAxis.Global,
GetName(lusasPointLoad));
int adapterNameId = lusasPointLoad.getID();
pointLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(pointLoad);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private static IEnumerable <IGrouping <string, IFAssignment> > GetLoadAssignments(IFLoading lusasForce)
{
object[] assignmentObjects = lusasForce.getAssignments();
List <IFAssignment> assignments = new List <IFAssignment>();
for (int j = 0; j < assignmentObjects.Count(); j++)
{
IFAssignment assignment = (IFAssignment)assignmentObjects[j];
assignments.Add(assignment);
}
IEnumerable <IGrouping <string, IFAssignment> > groupedByLoadcases =
assignments.GroupBy(m => m.getAssignmentLoadset().getName());
return(groupedByLoadcases);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static BarVaryingDistributedLoad ToBarDistributedLoad(IFLoading lusasBarDistributedLoad,
IEnumerable <IFAssignment> lusasAssignments, Dictionary <string, Bar> bars)
{
IFLoadcase assignedLoadcase = (IFLoadcase)lusasAssignments.First().getAssignmentLoadset();
Loadcase loadcase = ToLoadcase(assignedLoadcase);
IEnumerable <Bar> assignedBars = GetLineAssignments(lusasAssignments, bars);
Vector startForceVector = new Vector
{
X = lusasBarDistributedLoad.getValue("startpx"),
Y = lusasBarDistributedLoad.getValue("startpy"),
Z = lusasBarDistributedLoad.getValue("startpz")
};
Vector endForceVector = new Vector
{
X = lusasBarDistributedLoad.getValue("endpx"),
Y = lusasBarDistributedLoad.getValue("endpy"),
Z = lusasBarDistributedLoad.getValue("endpz")
};
Vector startMomentVector = new Vector
{
X = lusasBarDistributedLoad.getValue("startmx"),
Y = lusasBarDistributedLoad.getValue("startmy"),
Z = lusasBarDistributedLoad.getValue("startmz")
};
Vector endMomentVector = new Vector
{
X = lusasBarDistributedLoad.getValue("endmx"),
Y = lusasBarDistributedLoad.getValue("endmy"),
Z = lusasBarDistributedLoad.getValue("endmz")
};
double startPosition = lusasBarDistributedLoad.getValue("startDistance");
double endPosition = lusasBarDistributedLoad.getValue("endDistance");
bool relativePositions = lusasBarDistributedLoad.getValue("Type") == "Parametric" ? true : false;
LoadAxis axis = LoadAxis.Global;
bool projected = false;
BH.Engine.Base.Compute.RecordWarning("All BarVaryingDistributedLoads pulled from Lusas are assumed to be in global coordinates and to not be projected.");
BarVaryingDistributedLoad barVarDistributedLoad;
barVarDistributedLoad = Engine.Structure.Create.BarVaryingDistributedLoad(
loadcase,
assignedBars,
startPosition,
startForceVector,
startMomentVector,
endPosition,
endForceVector,
endMomentVector,
relativePositions,
axis,
projected,
GetName(lusasBarDistributedLoad));
if (barVarDistributedLoad == null)
{
return(null);
}
int adapterNameId = lusasBarDistributedLoad.getID();
barVarDistributedLoad.SetAdapterId(typeof(LusasId), adapterNameId);
return(barVarDistributedLoad);
}
